Add methods for getting all symbols and subSymbols of a scope

monticore-generator/src/main/java/de/monticore/codegen/cd2java/_symboltable/scope/ScopeClassDecorator.java

@@ -27,14 +27,12 @@
 import de.monticore.types.mcsimplegenerictypes._ast.ASTMCBasicGenericType;
 import de.se_rwth.commons.Names;
 import de.se_rwth.commons.StringTransformations;
-
 import java.util.*;
 import java.util.stream.Collectors;
 
 import static de.monticore.cd.codegen.CD2JavaTemplates.EMPTY_BODY;
 import static de.monticore.cd.codegen.CD2JavaTemplates.VALUE;
-import static de.monticore.cd.facade.CDModifier.PROTECTED;
-import static de.monticore.cd.facade.CDModifier.PUBLIC;
+import static de.monticore.cd.facade.CDModifier.*;
 import static de.monticore.codegen.cd2java._ast.ast_class.ASTConstants.AST_INTERFACE;
 import static de.monticore.codegen.cd2java._symboltable.SymbolTableConstants.*;
 import static de.monticore.codegen.cd2java._visitor.VisitorConstants.VISITOR_PREFIX;
@@ -123,7 +121,7 @@ public ASTCDClass decorate(ASTCDCompilationUnit scopeInput, ASTCDCompilationUnit
         symbolInput.getCDDefinition().getCDClassesList(), symbolTableService.getCDSymbol());
     symbolAttributes.putAll(getSuperSymbolAttributes());
 
-    List<ASTCDMethod> symbolMethods = createSymbolMethods(symbolAttributes.values());
+    List<ASTCDMethod> symbolMethods = createSymbolMethods(symbolAttributes.values(), symbolInput.getCDDefinition());
 
     List<ASTCDAttribute> symbolAlreadyResolvedAttributes = createSymbolAlreadyResolvedAttributes(
         symbolAttributes.keySet());
@@ -300,7 +298,7 @@ protected Map<String, ASTCDAttribute> createSymbolAttributes(
   }
 
   /**
-   * only returns a attribute if the cdType really defines a symbol
+   * only returns an attribute if the cdType really defines a symbol
    */
   protected Optional<ASTCDAttribute> createSymbolAttribute(ASTCDType cdType,
       DiagramSymbol cdDefinitionSymbol) {
@@ -334,7 +332,7 @@ protected List<ASTCDAttribute> createSymbolAlreadyResolvedAttributes(
     return symbolAttributeList;
   }
 
-  protected List<ASTCDMethod> createSymbolMethods(Collection<ASTCDAttribute> astcdAttributes) {
+  protected List<ASTCDMethod> createSymbolMethods(Collection<ASTCDAttribute> astcdAttributes, ASTCDDefinition symbolInput) {
     List<ASTCDMethod> symbolMethodList = new ArrayList<>();
     for (ASTCDAttribute attribute : astcdAttributes) {
       if (attribute.getMCType() instanceof ASTMCBasicGenericType
@@ -345,6 +343,7 @@ protected List<ASTCDMethod> createSymbolMethods(Collection<ASTCDAttribute> astcd
           symbolMethodList.add(createAddSymbolMethod(mcTypeArgument.get(), attribute.getName()));
           symbolMethodList.add(createRemoveSymbolMethod(mcTypeArgument.get(), attribute.getName()));
           symbolMethodList.add(createGetSymbolListMethod(attribute));
+          symbolMethodList.add(createGetSymbolsWithSubKindsMethod(attribute, symbolInput));
         }
       }
     }
@@ -377,6 +376,41 @@ protected ASTCDMethod createGetSymbolListMethod(ASTCDAttribute astcdAttribute) {
     return method;
   }
 
+  protected ASTCDMethod createGetSymbolsWithSubKindsMethod(ASTCDAttribute astcdAttribute, ASTCDDefinition symbolDefinition) {
+    ASTMCType returnType = astcdAttribute.getMCType();
+    ASTCDAttribute returnAttribute = getCDAttributeFacade()
+            .createAttribute(PROTECTED.build(), returnType, astcdAttribute.getName());
+
+    ASTCDMethod method = getCDMethodFacade().createMethod(PUBLIC.build(), returnAttribute.getMCType(),
+            "get" + StringTransformations.capitalize(astcdAttribute.getName())+"WithSubKinds");
+
+    //calculate subkindsMap for the symbol
+    Set<String> result = new HashSet<>();
+    List<ASTCDType> symbols = symbolTableService.getSymbolDefiningProds(symbolDefinition);
+    symbols.addAll(symbolTableService.getSymbolDefiningSuperProds());
+    ListMultimap<String, String> subKinds = SymbolKindHierarchies
+            .calculateSubKinds(symbols, symbolTableService);
+
+    //get names of attribute and check the subkindsMap for them recursively
+    List<String> lastAttributeNames = new ArrayList<>();
+    //as all attribute come in the Form <kind>Symbols,
+    // we need to cut the Symbols part away and capitalize the first letter
+    lastAttributeNames.add(StringTransformations.capitalize(symbolTableService.getSimpleNameFromSymbolName(astcdAttribute.getName())));
+    while (!lastAttributeNames.isEmpty()){
+      List<String> newAttributeNames = new ArrayList<>();
+      for(String s: lastAttributeNames){
+        //get all subkinds that match the same string key as the attribute
+        newAttributeNames.addAll(subKinds.get(s));
+        result.addAll(subKinds.get(s));
+      }
+      lastAttributeNames = newAttributeNames;
+    }
+
+    this.replaceTemplate(EMPTY_BODY, method, new TemplateHookPoint(TEMPLATE_PATH + "GetSymbolsWithSubKinds",
+            StringTransformations.capitalize(astcdAttribute.getName()), returnAttribute.getMCType().printType(), result));
+    return method;
+  }
+
   protected ASTCDAttribute createEnclosingScopeAttribute() {
     ASTCDAttribute attribute = this.getCDAttributeFacade()
         .createAttribute(PROTECTED.build(), symbolTableService.getScopeInterfaceType(),

monticore-generator/src/main/java/de/monticore/codegen/cd2java/_symboltable/scope/ScopeInterfaceDecorator.java

@@ -30,7 +30,6 @@
 import de.se_rwth.commons.Joiners;
 import de.se_rwth.commons.Names;
 import de.se_rwth.commons.StringTransformations;
-
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -259,6 +258,10 @@ protected List<ASTCDMethod> createScopeInterfaceMethodsForSymbols(List<? extends
       String getSymbolsMethodName = "get" + className + "Symbols";
       resolveMethods.add(createGetSymbolsMethod(getSymbolsMethodName, symbolFullTypeName));
 
+      //getSymbolsWithSubKinds method
+      String getSymbolsWithSubKindsMethodName = "get" + className + "SymbolsWithSubKinds";
+      resolveMethods.add(createGetSymbolsWithSubKindsMethod(getSymbolsWithSubKindsMethodName, symbolFullTypeName, symbolProd.getSymbol()));
+
       //getLocalSymbols method
       String getLocalSymbolsMethodName = "getLocal" + className + "Symbols";
       resolveMethods.add(createGetLocalSymbolsMethod(getLocalSymbolsMethodName, className, getMCTypeFacade().createListTypeOf(symbolFullTypeName)));
@@ -516,6 +519,12 @@ protected ASTCDMethod createGetSymbolsMethod(String methodName, String fullSymbo
     return getCDMethodFacade().createMethod(PUBLIC_ABSTRACT.build(), symbolsMap, methodName);
   }
 
+  protected ASTCDMethod createGetSymbolsWithSubKindsMethod(String methodName, String fullSymbolName, CDTypeSymbol type) {
+    ASTMCType symbolsMap = getMCTypeFacade().createBasicGenericTypeOf(SYMBOL_MULTI_MAP, "String", fullSymbolName);
+
+    return getCDMethodFacade().createMethod(PUBLIC_ABSTRACT.build(), symbolsMap, methodName);
+  }
+
   protected ASTCDMethod createGetLocalSymbolsMethod(String methodName, String className, ASTMCType returnType) {
     ASTCDMethod method = getCDMethodFacade().createMethod(PUBLIC.build(), returnType, methodName);
     this.replaceTemplate(EMPTY_BODY, method, new StringHookPoint("return get" + className + "Symbols().values();"));

monticore-generator/src/main/resources/_symboltable/scope/GetSymbolsWithSubKinds.ftl

@@ -0,0 +1,8 @@
+<#-- (c) https://github.com/MontiCore/monticore -->
+${tc.signature("fullSymbolName", "fullSymbolType", "allSymbolSubKinds")}
+    ${fullSymbolType} symbols = com.google.common.collect.LinkedListMultimap.create();
+    symbols.putAll(get${fullSymbolName}());
+<#list allSymbolSubKinds as subKind>
+    symbols.putAll(get${subKind}Symbols());
+</#list>
+    return symbols;

monticore-generator/src/test/java/de/monticore/codegen/cd2java/DecoratorTestUtil.java

@@ -90,6 +90,14 @@ public static List<ASTCDMethod> getMethodsBy(String name, int parameterSize, Lis
         m -> parameterSize == m.getCDParameterList().size()));
   }
 
+  public static List<ASTCDMethod> getMethodsBy(List<ASTCDMethod> methods, List<Predicate<ASTCDMethod>> predicates) {
+    return filterMethods(methods, predicates);
+  }
+
+  public static ASTCDMethod getMethodBy(List<ASTCDMethod> methods, List<Predicate<ASTCDMethod>> predicates) {
+    return filterMethodsOrFail(methods, predicates);
+  }
+
   public static ASTCDMethod getMethodBy(String name, List<ASTCDMethod> methods) {
     return filterMethodsOrFail(methods, Collections.singletonList(
         m -> name.equals(m.getName())));

monticore-generator/src/test/java/de/monticore/codegen/cd2java/_symboltable/scope/ScopeClassDecoratorTest.java

@@ -23,10 +23,9 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
+import java.util.function.Predicate;
+
 
 import static de.monticore.cd.facade.CDModifier.PROTECTED;
 import static de.monticore.cd.facade.CDModifier.PUBLIC;
@@ -60,6 +59,8 @@ public class ScopeClassDecoratorTest extends DecoratorTestCase {
 
   private static final String QUALIFIED_NAME_SYMBOL_MAP = "com.google.common.collect.LinkedListMultimap<String,de.monticore.codegen.ast.lexicals._symboltable.QualifiedNameSymbol>";
 
+  private static final String UNKNOWN_SYMBOL_MAP = "com.google.common.collect.LinkedListMultimap<String,de.monticore.symboltable.SymbolWithScopeOfUnknownKind>";
+
   private static final String FOO_SYMBOL_MAP = "com.google.common.collect.LinkedListMultimap<String,de.monticore.codegen.symboltable.automaton._symboltable.FooSymbol>";
 
   private static final String AUTOMATON_SYMBOL = "de.monticore.codegen.symboltable.automaton._symboltable.AutomatonSymbol";
@@ -83,7 +84,6 @@ public class ScopeClassDecoratorTest extends DecoratorTestCase {
   @BeforeEach
   public void setUp() {
     this.mcTypeFacade = mcTypeFacade.getInstance();
-
     ASTCDCompilationUnit astcdCompilationUnit = this.parse("de", "monticore", "codegen", "symboltable", "Automaton");
     decoratedSymbolCompilationUnit = this.parse("de", "monticore", "codegen", "symboltable", "AutomatonSymbolCD");
     decoratedScopeCompilationUnit = this.parse("de", "monticore", "codegen", "symboltable", "AutomatonScopeCD");
@@ -375,7 +375,7 @@ public void testScopeRuleAttributes() {
 
   @Test
   public void testMethodCount() {
-    assertEquals(99, scopeClass.getCDMethodList().size());
+    assertEquals(104, scopeClass.getCDMethodList().size());
 
     assertTrue(Log.getFindings().isEmpty());
   }
@@ -467,8 +467,6 @@ public void testAddSymbolMethod() {
     assertTrue(Log.getFindings().isEmpty());
   }
 
-
-
   @Test
   public void testGetAutomatonSymbolsMethod() {
     ASTCDMethod method = getMethodBy("getAutomatonSymbols", scopeClass);
@@ -481,6 +479,46 @@ public void testGetAutomatonSymbolsMethod() {
     assertTrue(Log.getFindings().isEmpty());
   }
 
+  @Test
+  public void testGetSymbolWithSubKindsMethod() {
+    List<Predicate<ASTCDMethod>> predicates = Arrays.asList(
+            m -> m.getName().endsWith("WithSubKinds")
+    );
+    List<ASTCDMethod> methodList = getMethodsBy(scopeClass.getCDMethodList(), predicates);
+    Map<String, ASTCDMethod> methods = new HashMap<>();
+    methodList.forEach(l -> methods.put(
+            CD4CodeMill.prettyPrint(l.getMCReturnType().getMCType(), false), l)
+    );
+
+    assertEquals(5, methodList.size());
+
+    ASTCDMethod automatonAdd = methods.get(AUTOMATON_SYMBOL_MAP);
+    assertDeepEquals(PUBLIC, automatonAdd.getModifier());
+    assertTrue(automatonAdd.isEmptyCDParameters());
+    assertEquals("getAutomatonSymbolsWithSubKinds", automatonAdd.getName());
+
+    ASTCDMethod stateAdd = methods.get(STATE_SYMBOL_MAP);
+    assertDeepEquals(PUBLIC, stateAdd.getModifier());
+    assertTrue(stateAdd.isEmptyCDParameters());
+    assertEquals("getStateSymbolsWithSubKinds", stateAdd.getName());
+
+    ASTCDMethod qualifiedNameAdd = methods.get(QUALIFIED_NAME_SYMBOL_MAP);
+    assertDeepEquals(PUBLIC, qualifiedNameAdd.getModifier());
+    assertTrue(qualifiedNameAdd.isEmptyCDParameters());
+    assertEquals("getQualifiedNameSymbolsWithSubKinds", qualifiedNameAdd.getName());
+
+    ASTCDMethod unknownAdd = methods.get(UNKNOWN_SYMBOL_MAP);
+    assertDeepEquals(PUBLIC, unknownAdd.getModifier());
+    assertTrue(unknownAdd.isEmptyCDParameters());
+    assertEquals("getUnknownSymbolsWithSubKinds", unknownAdd.getName());
+
+    ASTCDMethod fooAdd = methods.get(FOO_SYMBOL_MAP);
+    assertDeepEquals(PUBLIC, fooAdd.getModifier());
+    assertTrue(fooAdd.isEmptyCDParameters());
+    assertEquals("getFooSymbolsWithSubKinds", fooAdd.getName());
+
+    assertTrue(Log.getFindings().isEmpty());
+  }
 
   @Test
   public void testGetStateSymbolsMethod() {