Refactor IncarnationContext and related classes to use StableElementKey for mappings and reduce complexity

Author: PresiProdanov

ref-code-adaptation/README.md

@@ -119,6 +119,9 @@ assignments are rewritten only inside that owning Java type.
   superclasses, modifiers, and type-reference printing. Runtime Java reflection
   is not used by the adapter.
 - `ManualIncarnationContextBuilder` is the non-mutating context builder for `useConcretization=false`.
+- `IncarnationContext` owns one immutable stable-key mapping. MontiCore symbols
+  are retained only as mapped-element payload for AST operations; symbol object
+  identity is not used for incarnation lookup.
 - `AdaptationConflictDetector` validates manual mappings before Java output is written.
 - `JavaTypeUpdateService` fills Java-expressible gaps only after
   cdconcretization, such as missing fields, methods, types, enum constants,

ref-code-adaptation/src/main/java/de/monticore/codeAdaption/AdaptedCodeMerger.java

@@ -2,6 +2,7 @@
 
 import de.monticore.cdbasis._ast.ASTCDCompilationUnit;
 import de.monticore.codeAdaption.handler.multiIncarnation.IncarnationContext;
+import de.monticore.codeAdaption.handler.multiIncarnation.StableElementKey;
 import de.monticore.codeAdaption.utils.AdapterUtils;
 import de.monticore.codeAdaption.utils.CDModelIndex;
 import de.monticore.codeAdaption.utils.visitors.JavaAstElemCollector;
@@ -12,7 +13,6 @@
 import de.monticore.java.javadsl._ast.ASTOrdinaryCompilationUnit;
 import de.monticore.java.javadsl._ast.ASTTypeDeclaration;
 import de.monticore.java.javadsl._visitor.JavaDSLTraverser;
-import de.monticore.symboltable.ISymbol;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -41,7 +41,8 @@ Set<ASTOrdinaryCompilationUnit> mergeAdaptedCode(
   Set<ASTOrdinaryCompilationUnit> filterCodeForMapping(
       Set<ASTOrdinaryCompilationUnit> javaFiles,
       CodeValidator validator,
-      IncarnationContext context) {
+      IncarnationContext context,
+      CDModelIndex referenceIndex) {
     validator.initializeTypeMatcher(javaFiles);
     Set<ASTOrdinaryCompilationUnit> result = new LinkedHashSet<>();
     for (ASTOrdinaryCompilationUnit unit : javaFiles) {
@@ -54,10 +55,10 @@ Set<ASTOrdinaryCompilationUnit> filterCodeForMapping(
               .map(Optional::get)
               .flatMap(matching -> matching.getReferences().stream())
               .anyMatch(
-                  reference -> {
-                    List<ISymbol> incarnations = context.getIncarnations(reference);
-                    return incarnations != null && !incarnations.isEmpty();
-                  });
+                  reference -> StableElementKey.fromSymbol(reference, referenceIndex)
+                      .map(context::getIncarnations)
+                      .filter(incarnations -> !incarnations.isEmpty())
+                      .isPresent());
       boolean ignoredTopLevel =
           collector.getAllTypeDeclarations().stream()
               .map(validator::getMatchedType)

ref-code-adaptation/src/main/java/de/monticore/codeAdaption/CodeAdapter.java

@@ -183,7 +183,8 @@ private void adaptInternal(
       Set<ASTOrdinaryCompilationUnit> mappingCode = cloneUnits(refCode);
       mappingCode = codeMerger.splitCompilationUnitsByType(mappingCode);
       mappingCode =
-          codeMerger.filterCodeForMapping(mappingCode, validators.get(mapping), ctx);
+          codeMerger.filterCodeForMapping(
+              mappingCode, validators.get(mapping), ctx, referenceIndex);
 
       for (AdaptationPass pass :
           buildAdaptationPasses(
@@ -222,7 +223,7 @@ private void adaptInternal(
                     checkers.get(mapping),
                     updater,
                     validators.get(mapping),
-                    createSelector(pass.typeSelection(), ctx),
+                    createSelector(pass.typeSelection(), ctx, referenceIndex, conIndex),
                     Map.of(mapping, ctx),
                     ctx,
                     mapping,
@@ -309,39 +310,45 @@ private static List<AdaptationPass> buildAdaptationPasses(
             validator.getMatchedType(type),
             context,
             relevantTypes,
+            referenceIndex,
             useCommonParentForMultipleIncarnations);
         for (var field : collector.getAllFieldDeclarations(type)) {
           addRelevantTypeReferences(
               validator.getMatchedField(type, field),
               context,
               relevantTypes,
+              referenceIndex,
               useCommonParentForMultipleIncarnations);
         }
         for (var supertype : collector.getAllFSuperTypeDeclarations(type)) {
           addRelevantTypeReferences(
               validator.getMatchedSupertype(type, supertype),
               context,
               relevantTypes,
+              referenceIndex,
               useCommonParentForMultipleIncarnations);
         }
         for (var method : collector.getAllMethodDeclarations(type)) {
           addRelevantTypeReferences(
               validator.getMatchedMethod(type, method),
               context,
               relevantTypes,
+              referenceIndex,
               useCommonParentForMultipleIncarnations);
           for (var parameter : collector.getAllParameters(type, method)) {
             addRelevantTypeReferences(
                 validator.getMatchedParameter(type, method, parameter),
                 context,
                 relevantTypes,
+                referenceIndex,
                 useCommonParentForMultipleIncarnations);
           }
           for (var local : collector.getAllLocVariables(type, method)) {
             addRelevantTypeReferences(
                 validator.getMatchedLocalVariable(type, method, local),
                 context,
                 relevantTypes,
+                referenceIndex,
                 useCommonParentForMultipleIncarnations);
           }
         }
@@ -355,7 +362,7 @@ private static List<AdaptationPass> buildAdaptationPasses(
         Map<ISymbol, ISymbol> selection = Map.of();
         defaultUnits.add(unit);
         defaultOutputTypeNames.addAll(
-            expectedOutputTypeNames(unit, validator, context, selection));
+            expectedOutputTypeNames(unit, validator, context, selection, referenceIndex));
       } else {
         for (Map<ISymbol, ISymbol> selection :
             buildCompleteTypeSelections(
@@ -368,7 +375,7 @@ private static List<AdaptationPass> buildAdaptationPasses(
               new AdaptationPass(
                   Set.of(unit),
                   selection,
-                  expectedOutputTypeNames(unit, validator, context, selection)));
+                  expectedOutputTypeNames(unit, validator, context, selection, referenceIndex)));
         }
       }
     }
@@ -393,6 +400,7 @@ private static void addRelevantTypeReferences(
       Optional<de.monticore.codeAdaption.matcher.CodeMatching> matching,
       IncarnationContext context,
       Map<StableElementKey, ISymbol> relevantTypes,
+      CDModelIndex referenceIndex,
       boolean useCommonParentForMultipleIncarnations) {
     if (matching.isEmpty() || !matching.get().mustBePerform()) {
       return;
@@ -401,24 +409,29 @@ private static void addRelevantTypeReferences(
       if (!(reference instanceof de.monticore.cdbasis._symboltable.CDTypeSymbol)) {
         continue;
       }
-      List<ISymbol> incarnations = context.getIncarnations(reference);
-      if (incarnations == null
-          || incarnations.size() < 2
+      List<IncarnationContext.MappedElement> incarnations =
+          StableElementKey.fromSymbol(reference, referenceIndex)
+              .map(context::getIncarnations)
+              .orElseGet(List::of);
+      if (incarnations.size() < 2
           || (useCommonParentForMultipleIncarnations
               && isExactGroupingSet(context, incarnations))) {
         continue;
       }
-      context.getStableKey(reference).ifPresent(key -> relevantTypes.put(key, reference));
+      StableElementKey.fromSymbol(reference, referenceIndex)
+          .ifPresent(key -> relevantTypes.put(key, reference));
     }
   }
 
   private static boolean isExactGroupingSet(
-      IncarnationContext context, List<ISymbol> incarnations) {
+      IncarnationContext context, List<IncarnationContext.MappedElement> incarnations) {
     Set<String> incarnationNames =
-        incarnations.stream().map(ISymbol::getName).collect(java.util.stream.Collectors.toSet());
+        incarnations.stream()
+            .map(element -> element.key().getName())
+            .collect(java.util.stream.Collectors.toSet());
     Set<String> derivedGroupings =
         incarnationNames.stream()
-            .map(context::findGroupingTypeForImplementer)
+            .map(name -> groupingName(context, name))
             .flatMap(Optional::stream)
             .collect(java.util.stream.Collectors.toSet());
     if (derivedGroupings.size() == 1) {
@@ -428,8 +441,7 @@ private static boolean isExactGroupingSet(
               .allMatch(
                   incarnation ->
                       grouping.equals(incarnation)
-                          || context
-                              .findGroupingTypeForImplementer(incarnation)
+                          || groupingName(context, incarnation)
                               .filter(grouping::equals)
                               .isPresent());
       if (everyIncarnationBelongsToGrouping) {
@@ -443,7 +455,7 @@ private static boolean isExactGroupingSet(
         if (possibleGrouping.equals(incarnation)) {
           continue;
         }
-        Optional<String> grouping = context.findGroupingTypeForImplementer(incarnation);
+        Optional<String> grouping = groupingName(context, incarnation);
         foundImplementer |= grouping.isPresent();
         if (grouping.isEmpty() || !possibleGrouping.equals(grouping.get())) {
           exact = false;
@@ -461,7 +473,8 @@ private static Set<String> expectedOutputTypeNames(
       ASTOrdinaryCompilationUnit unit,
       CodeValidator validator,
       IncarnationContext context,
-      Map<ISymbol, ISymbol> selection) {
+      Map<ISymbol, ISymbol> selection,
+      CDModelIndex referenceIndex) {
     Set<String> result = new LinkedHashSet<>();
     for (var type : unit.getTypeDeclarationList()) {
       Optional<CodeMatching> matching = validator.getMatchedType(type);
@@ -472,7 +485,8 @@ private static Set<String> expectedOutputTypeNames(
       boolean resolved = false;
       List<ISymbol> concreteReferences = new ArrayList<>();
       for (ISymbol reference : matching.get().getReferences()) {
-        ISymbol selected = selectedIncarnation(reference, selection, context);
+        ISymbol selected =
+            selectedIncarnation(reference, selection, context, referenceIndex);
         concreteReferences.add(selected == null ? reference : selected);
         resolved |= selected != null;
       }
@@ -493,26 +507,35 @@ private static Set<String> expectedOutputTypeNames(
   private static ISymbol selectedIncarnation(
       ISymbol reference,
       Map<ISymbol, ISymbol> selection,
-      IncarnationContext context) {
+      IncarnationContext context,
+      CDModelIndex referenceIndex) {
     ISymbol selected = selection.get(reference);
+    Optional<StableElementKey> referenceKey =
+        StableElementKey.fromSymbol(reference, referenceIndex);
     if (selected == null) {
-      Optional<StableElementKey> referenceKey = context.getStableKey(reference);
       selected =
           selection.entrySet().stream()
-              .filter(entry -> referenceKey.equals(context.getStableKey(entry.getKey())))
+              .filter(
+                  entry ->
+                      referenceKey.equals(
+                          StableElementKey.fromSymbol(entry.getKey(), referenceIndex)))
               .map(Map.Entry::getValue)
               .findFirst()
               .orElse(null);
     }
     if (selected != null) {
       return selected;
     }
-    List<ISymbol> incarnations = context.getIncarnations(reference);
-    return incarnations != null && incarnations.size() == 1 ? incarnations.get(0) : null;
+    List<IncarnationContext.MappedElement> incarnations =
+        referenceKey.map(context::getIncarnations).orElseGet(List::of);
+    return incarnations.size() == 1 ? incarnations.get(0).symbol() : null;
   }
 
   private static IncarnationSelector createSelector(
-      Map<ISymbol, ISymbol> typeSelection, IncarnationContext context) {
+      Map<ISymbol, ISymbol> typeSelection,
+      IncarnationContext context,
+      CDModelIndex referenceIndex,
+      CDModelIndex concreteIndex) {
     return (referenceSymbol, availableIncarnations, ignored) -> {
       if (availableIncarnations == null || availableIncarnations.isEmpty()) {
         return null;
@@ -522,14 +545,15 @@ private static IncarnationSelector createSelector(
         return selectedType;
       }
       Optional<String> referenceOwner =
-          context.getStableKey(referenceSymbol).flatMap(StableElementKey::getOwnerType);
+          StableElementKey.fromSymbol(referenceSymbol, referenceIndex)
+              .flatMap(StableElementKey::getOwnerType);
       if (referenceOwner.isPresent()) {
         Optional<ISymbol> selectedOwner =
             typeSelection.entrySet().stream()
                 .filter(
                     entry ->
-                        context
-                            .getStableKey(entry.getKey())
+                        StableElementKey
+                            .fromSymbol(entry.getKey(), referenceIndex)
                             .filter(key -> key.getKind() == StableElementKey.Kind.TYPE)
                             .map(StableElementKey::getName)
                             .filter(referenceOwner.get()::equals)
@@ -541,8 +565,8 @@ private static IncarnationSelector createSelector(
               availableIncarnations.stream()
                   .filter(
                       candidate ->
-                          context
-                              .getStableKey(candidate)
+                          StableElementKey
+                              .fromSymbol(candidate, concreteIndex)
                               .flatMap(StableElementKey::getOwnerType)
                               .filter(selectedOwner.get().getName()::equals)
                               .isPresent())
@@ -556,8 +580,8 @@ private static IncarnationSelector createSelector(
       Map<ISymbol, Integer> scores = new IdentityHashMap<>();
       for (ISymbol candidate : availableIncarnations) {
         String identity =
-            context
-                .getStableKey(candidate)
+            StableElementKey
+                .fromSymbol(candidate, concreteIndex)
                 .map(StableElementKey::toString)
                 .orElse(candidate.getName())
                 .toLowerCase(Locale.ROOT);
@@ -613,12 +637,16 @@ private static List<Map<ISymbol, ISymbol>> buildCompleteTypeSelections(
     selections.add(new IdentityHashMap<>());
     for (ISymbol referenceType : referenceTypes) {
       List<ISymbol> incarnations =
-          new ArrayList<>(
-              Objects.requireNonNull(context.getIncarnations(referenceType), "incarnations"));
+          context
+              .getIncarnations(
+                  StableElementKey.fromSymbol(referenceType, referenceIndex).orElseThrow())
+              .stream()
+              .map(IncarnationContext.MappedElement::symbol)
+              .collect(java.util.stream.Collectors.toCollection(ArrayList::new));
       incarnations.removeIf(incarnation -> !concreteIndex.hasType(incarnation.getName()));
       String referenceName =
-          context
-              .getStableKey(referenceType)
+          StableElementKey
+              .fromSymbol(referenceType, referenceIndex)
               .map(StableElementKey::getName)
               .orElse(referenceType.getName());
       if (incarnations.size() > 1 && !inputConcreteIndex.hasType(referenceName)) {
@@ -672,6 +700,13 @@ private static boolean sameTypeKind(
             && incarnation instanceof de.monticore.cdinterfaceandenum._ast.ASTCDEnum);
   }
 
+  private static Optional<String> groupingName(
+      IncarnationContext context, String concreteTypeName) {
+    return context
+        .getGroupingFor(StableElementKey.type(concreteTypeName))
+        .map(grouping -> grouping.key().getName());
+  }
+
   private static String describeSelection(Map<ISymbol, ISymbol> selection) {
     return selection.entrySet().stream()
         .sorted(Map.Entry.comparingByKey(Comparator.comparing(ISymbol::getName)))

ref-code-adaptation/src/main/java/de/monticore/codeAdaption/context/GroupingMappingService.java

@@ -1,9 +1,7 @@
 package de.monticore.codeAdaption.context;
 
 import de.monticore.codeAdaption.handler.multiIncarnation.IncarnationContext;
-import de.monticore.symboltable.ISymbol;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
 
 /** Computes concrete-type to grouping-type replacements from incarnation contexts. */
@@ -18,23 +16,16 @@ public Map<String, String> compute(Map<String, IncarnationContext> mappingContex
   /** Computes replacements for one mapping only, preventing one mapping from leaking into another. */
   public Map<String, String> compute(IncarnationContext context) {
     Map<String, String> result = new LinkedHashMap<>();
-    context.getReferenceToIncarnations().entrySet().stream()
-        .sorted(Map.Entry.comparingByKey(java.util.Comparator.comparing(ISymbol::getName)))
-        .forEach(entry -> {
-        List<ISymbol> incarnations = entry.getValue();
-        if (incarnations == null) {
-          return;
-        }
-        incarnations.stream().filter(java.util.Objects::nonNull).sorted(java.util.Comparator.comparing(ISymbol::getName)).forEach(incarnation -> {
-          if (incarnation == null) {
-            return;
-          }
-          var groupingType = context.findGroupingTypeForImplementer(incarnation.getName());
-          if (groupingType.isPresent() && !groupingType.get().equals(incarnation.getName())) {
-            putUnambiguous(result, incarnation.getName(), groupingType.get());
-          }
-        });
-      });
+    context.getGroupingMappings().entrySet().stream()
+        .sorted(Map.Entry.comparingByKey(java.util.Comparator.comparing(key -> key.signature())))
+        .forEach(
+            entry -> {
+              String concrete = entry.getKey().getName();
+              String grouping = entry.getValue().key().getName();
+              if (!grouping.equals(concrete)) {
+                putUnambiguous(result, concrete, grouping);
+              }
+            });
     return result;
   }