Port Att.scala to Java

kernel/src/main/java/org/kframework/backend/kore/ModuleToKORE.java

@@ -2013,7 +2013,10 @@ private void convert(
 
     for (Tuple2<Tuple2<Att.Key, String>, ?> attribute :
         // Sort to stabilize error messages
-        stream(att.att()).sorted(Comparator.comparing(Tuple2::toString)).toList()) {
+        stream(att.att())
+            .filter(e -> e._1._1.shouldEmit())
+            .sorted(Comparator.comparing(Tuple2::toString))
+            .toList()) {
       Att.Key key = attribute._1._1;
       String strKey = key.key();
       String clsName = attribute._1._2;

kore/src/main/java/org/kframework/attributes/Attribute.java

@@ -0,0 +1,45 @@
+// Copyright (c) Runtime Verification, Inc. All Rights Reserved.
+package org.kframework.attributes;
+
+import com.google.common.collect.Sets;
+import java.util.Arrays;
+import java.util.EnumSet;
+
+public abstract class Attribute {
+
+  public enum Syntax {
+    CELL,
+    CLAIM,
+    CONTEXT,
+    CONTEXT_ALIAS,
+    MODULE,
+    PRODUCTION,
+    RULE,
+    SENTENCE,
+    SYNTAX_SORT,
+    UNCHECKED
+  }
+
+  public sealed interface Visibility {
+    record User(EnumSet<Syntax> allowedSyntax) implements Visibility {
+      User(Syntax... allowed) {
+        this(Sets.newEnumSet(Arrays.asList(allowed), Syntax.class));
+      }
+    }
+
+    record Internal() implements Visibility {}
+  }
+
+  public enum EmitToKORE {
+    YES,
+    NO
+  }
+
+  public final Visibility visibility;
+  public final EmitToKORE emit;
+
+  protected Attribute(Visibility visibility, EmitToKORE emit) {
+    this.visibility = visibility;
+    this.emit = emit;
+  }
+}

kore/src/main/java/org/kframework/attributes/ClassSet.java

@@ -0,0 +1,34 @@
+// Copyright (c) Runtime Verification, Inc. All Rights Reserved.
+package org.kframework.attributes;
+
+import java.util.Objects;
+import java.util.Optional;
+import org.pcollections.HashPMap;
+
+public class ClassSet<U> {
+
+  public final HashPMap<Class<? extends U>, Object> data;
+
+  private ClassSet(HashPMap<Class<? extends U>, Object> data) {
+    this.data = data;
+  }
+
+  public <T extends U> ClassSet<U> add(Class<T> elemClass, T elem) {
+    return new ClassSet<>(data.plus(elemClass, elem));
+  }
+
+  public <T extends U> Optional<T> get(Class<T> elemClass) {
+    if (!data.containsKey(elemClass)) {
+      return Optional.empty();
+    }
+    return Optional.of(Objects.requireNonNull(elemClass.cast(data.get(elemClass))));
+  }
+
+  public <T extends U> boolean contains(Class<T> elemClass) {
+    return data.containsKey(elemClass);
+  }
+
+  public <T extends U> ClassSet<U> remove(Class<T> elemClass) {
+    return new ClassSet<>(data.minus(elemClass));
+  }
+}