Remove component deser overrides, use defaults, add parameter to symrules

monticore-grammar-emf/build.gradle

@@ -92,6 +92,7 @@ test {
   exclude '**/SynthesizeSymTypeFromMCFullGenericTypesTest.class'
   exclude '**/SynthesizeSymTypeFromMCArrayTypesTest.class'
   exclude '**/MCType2SymTypeExpressionTest.class'
+  exclude '**/ComponentSymbolDeSerTest.class'
 }
 
 

monticore-grammar/src/main/grammars/de/monticore/symbols/CompSymbols.mc4

@@ -14,6 +14,7 @@ component grammar CompSymbols extends de.monticore.symbols.BasicSymbols {
   symbolrule Component =
     superComponents: de.monticore.types.check.CompKindExpression*
     refinements: de.monticore.types.check.CompKindExpression*
+    parameter: de.monticore.symbols.basicsymbols._symboltable.VariableSymbol*
 
     method public List<de.monticore.symbols.basicsymbols._symboltable.TypeVarSymbol> getTypeParameters() {
       return this.getSpannedScope().getLocalTypeVarSymbols();

monticore-grammar/src/main/java/de/monticore/symbols/compsymbols/_symboltable/ComponentSymbol.java

@@ -2,7 +2,6 @@
 package de.monticore.symbols.compsymbols._symboltable;
 
 import com.google.common.base.Preconditions;
-import de.monticore.symbols.basicsymbols._symboltable.TypeVarSymbol;
 import de.monticore.symbols.basicsymbols._symboltable.VariableSymbol;
 import de.monticore.types.check.CompKindExpression;
 import de.se_rwth.commons.logging.Log;
@@ -18,32 +17,26 @@
 
 public class ComponentSymbol extends ComponentSymbolTOP {
 
-  protected List<VariableSymbol> parameters = new ArrayList<>();
-
   public ComponentSymbol(String name) {
     super(name);
   }
 
-  public List<VariableSymbol> getParameters() {
-    return this.parameters;
-  }
-
   public Optional<VariableSymbol> getParameter(@NonNull String name) {
     Preconditions.checkNotNull(name);
-    for (VariableSymbol parameter : this.getParameters()) {
+    for (VariableSymbol parameter : this.getParameterList()) {
       if (parameter.getName().equals(name)) return Optional.of(parameter);
     }
     return Optional.empty();
   }
 
-  public void addParameter(@NonNull VariableSymbol parameter) {
+  public boolean addParameter(@NonNull VariableSymbol parameter) {
     Preconditions.checkNotNull(parameter);
     Preconditions.checkArgument(this.getSpannedScope().getLocalVariableSymbols().contains(parameter));
-    this.parameters.add(parameter);
+    return super.addParameter(parameter);
   }
 
   public boolean hasParameters() {
-    return !this.getParameters().isEmpty();
+    return !this.getParameterList().isEmpty();
   }
 
   public boolean hasTypeParameter() {

monticore-grammar/src/main/java/de/monticore/symbols/compsymbols/_symboltable/ComponentSymbolDeSer.java

@@ -23,10 +23,7 @@
 public class ComponentSymbolDeSer extends ComponentSymbolDeSerTOP {
 
   public static final String PARAMETERS = "parameters";
-  public static final String PORTS = "ports";
-  public static final String TYPE_PARAMETERS = "typeParameters";
   public static final String SUPER = "super";
-  public static final String SUBCOMPONENTS = "subcomponents";
   public static final String REFINEMENTS = "refinements";
 
   private FullCompKindExprDeSer compTypeExprDeSer;
@@ -47,23 +44,8 @@ protected FullCompKindExprDeSer getCompTypeExprDeSer() {
   }
 
   @Override
-  public String serialize(@NonNull ComponentSymbol toSerialize, @NonNull CompSymbolsSymbols2Json s2j) {
-    JsonPrinter printer = s2j.getJsonPrinter();
-    printer.beginObject();
-    printer.member(JsonDeSers.KIND, getSerializedKind());
-    printer.member(JsonDeSers.NAME, toSerialize.getName());
-
-    // serialize symbolrule attributes
-    serializeSuperComponents(toSerialize.getSuperComponentsList(), s2j);
-
-    // Don't serialize the spanned scope (because it carries private information)
-    // Instead, serialize type parameters and normal parameters separately.
-    s2j.getTraverser().addTraversedElement(toSerialize.getSpannedScope());  // So the spanned scope is not visited
-
-    serializeAddons(toSerialize, s2j);
-    printer.endObject();
-
-    return printer.toString();
+  protected void deserializeAddons(ComponentSymbol symbol, JsonObject symbolJson) {
+    symbol.getParameterList().forEach(symbol.getSpannedScope()::add);
   }
 
   @Override
@@ -90,131 +72,35 @@ protected List<CompKindExpression> deserializeSuperComponents(JsonObject symbolJ
   }
 
   @Override
-  protected  void serializeAddons(ComponentSymbol toSerialize, CompSymbolsSymbols2Json s2j) {
-    serializeParameters(toSerialize, s2j);
-    serializePorts(toSerialize, s2j);
-    serializeTypeParameters(toSerialize, s2j);
-    serializeSubcomponents(toSerialize, s2j);
-  }
-
-  @Override
-  protected void deserializeAddons(ComponentSymbol symbol, JsonObject symbolJson) {
-    deserializeParameters(symbol, symbolJson);
-    deserializePorts(symbol, symbolJson);
-    deserializeTypeParameters(symbol, symbolJson);
-  }
-
-  protected void serializeParameters(@NonNull ComponentSymbol paramOwner, @NonNull CompSymbolsSymbols2Json s2j) {
+  protected void serializeParameter(List<VariableSymbol> parameter, CompSymbolsSymbols2Json s2j) {
     JsonPrinter printer = s2j.getJsonPrinter();
 
     printer.beginArray(PARAMETERS);
-    paramOwner.getParameters().forEach(p -> p.accept(s2j.getTraverser()));
+    parameter.forEach(p -> p.accept(s2j.getTraverser()));
     printer.endArray();
   }
 
-  protected void serializePorts(@NonNull ComponentSymbol portOwner, @NonNull CompSymbolsSymbols2Json s2j) {
-    JsonPrinter printer = s2j.getJsonPrinter();
-
-    printer.beginArray(PORTS);
-    portOwner.getPorts().forEach(p -> p.accept(s2j.getTraverser()));
-    printer.endArray();
-  }
-
-  /**
-   * @param paramOwner     the component which owns the parameter.
-   * @param paramOwnerJson the component which owns the parameters, encoded as JSON.
-   */
-  protected void deserializeParameters(@NonNull ComponentSymbol paramOwner, @NonNull JsonObject paramOwnerJson) {
+  @Override
+  protected List<VariableSymbol> deserializeParameter(JsonObject symbolJson) {
     final String varSerializeKind = VariableSymbol.class.getCanonicalName();
 
-    List<JsonElement> params = paramOwnerJson.getArrayMemberOpt(PARAMETERS).orElseGet(Collections::emptyList);
+    List<JsonElement> params = symbolJson.getArrayMemberOpt(PARAMETERS).orElseGet(Collections::emptyList);
+    List<VariableSymbol> parameterResult = new ArrayList<>(params.size());
 
     for (JsonElement param : params) {
       String paramJsonKind = JsonDeSers.getKind(param.getAsJsonObject());
       ISymbolDeSer<?, ?> deSer = CompSymbolsMill.globalScope().getSymbolDeSer(paramJsonKind);
       if (deSer != null && deSer.getSerializedKind().equals(varSerializeKind)) {
         VariableSymbol paramSym = (VariableSymbol) deSer.deserialize(param.getAsJsonObject());
-
-        paramOwner.getSpannedScope().add(paramSym);
-        paramOwner.addParameter(paramSym);
+        parameterResult.add(paramSym);
       } else {
         Log.error(String.format(
-            "0xD0101 Malformed json, parameter '%s' of unsupported kind '%s'",
-            param.getAsJsonObject().getStringMember(JsonDeSers.NAME), paramJsonKind
+          "0xD0101 Malformed json, parameter '%s' of unsupported kind '%s'",
+          param.getAsJsonObject().getStringMember(JsonDeSers.NAME), paramJsonKind
         ));
       }
     }
-  }
-
-  /**
-   * @param portOwner      the component which owns the parameter.
-   * @param paramOwnerJson the component which owns the parameters, encoded as JSON.
-   */
-  protected void deserializePorts(@NonNull ComponentSymbol portOwner, @NonNull JsonObject paramOwnerJson) {
-    final String portSerializeKind = PortSymbol.class.getCanonicalName();
-
-    List<JsonElement> ports = paramOwnerJson.getArrayMemberOpt(PORTS).orElseGet(Collections::emptyList);
-
-    for (JsonElement port : ports) {
-      String portJsonKind = JsonDeSers.getKind(port.getAsJsonObject());
-      ISymbolDeSer<?, ?> deSer = CompSymbolsMill.globalScope().getSymbolDeSer(portJsonKind);
-      if (deSer != null && deSer.getSerializedKind().equals(portSerializeKind)) {
-        PortSymbol portSym = (PortSymbol) deSer.deserialize(port.getAsJsonObject());
-
-        portOwner.getSpannedScope().add(portSym);
-      } else {
-        Log.error(String.format(
-            "0xD0102 Malformed json, port '%s' of unsupported kind '%s'",
-            port.getAsJsonObject().getStringMember(JsonDeSers.NAME), portJsonKind
-        ));
-      }
-    }
-  }
-
-  protected void serializeTypeParameters(@NonNull ComponentSymbol typeParamOwner, CompSymbolsSymbols2Json s2j) {
-    JsonPrinter printer = s2j.getJsonPrinter();
-
-    printer.beginArray(TYPE_PARAMETERS);
-    typeParamOwner.getTypeParameters().forEach(tp -> tp.accept(s2j.getTraverser()));
-    printer.endArray();
-  }
-
-  /**
-   * @param typeParamOwner     the component which owns the parameter.
-   * @param typeParamOwnerJson the component which owns the type parameters, encoded as JSON.
-   */
-  protected void deserializeTypeParameters(@NonNull ComponentSymbol typeParamOwner,
-                                           @NonNull JsonObject typeParamOwnerJson) {
-    final String typeVarSerializedKind = "de.monticore.symbols.basicsymbols._symboltable.TypeVarSymbol";
-
-    List<JsonElement> typeParams =
-        typeParamOwnerJson
-            .getArrayMemberOpt(TYPE_PARAMETERS)
-            .orElseGet(Collections::emptyList);
-
-    for (JsonElement typeParam : typeParams) {
-      String typeParamJsonKind = JsonDeSers.getKind(typeParam.getAsJsonObject());
-      ISymbolDeSer<?, ?> deSer = CompSymbolsMill.globalScope().getSymbolDeSer(typeParamJsonKind);
-      if (deSer != null && deSer.getSerializedKind().equals(typeVarSerializedKind)) {
-        TypeVarSymbol typeParamSym = (TypeVarSymbol) deSer.deserialize(typeParam.getAsJsonObject());
-
-        typeParamOwner.getSpannedScope().add(typeParamSym);
-      } else {
-        Log.error(String.format(
-            "0xD0103 Malformed json, type parameter '%s' of unsupported kind '%s'",
-            typeParam.getAsJsonObject().getStringMember(JsonDeSers.NAME), typeParamJsonKind
-        ));
-
-      }
-    }
-  }
-
-  protected void serializeSubcomponents(@NonNull ComponentSymbol portOwner, @NonNull CompSymbolsSymbols2Json s2j) {
-    JsonPrinter printer = s2j.getJsonPrinter();
-
-    printer.beginArray(SUBCOMPONENTS);
-    portOwner.getSubcomponents().forEach(p -> p.accept(s2j.getTraverser()));
-    printer.endArray();
+    return parameterResult;
   }
 
   @Override

monticore-grammar/src/main/java/de/monticore/symbols/compsymbols/_symboltable/SubcomponentSymbolDeSer.java

@@ -33,6 +33,6 @@ protected void serializeType(CompKindExpression type, CompSymbolsSymbols2Json s2
 
   @Override
   protected CompKindExpression deserializeType(JsonObject symbolJson) {
-    return null;
+    return this.getCompKindExprDeSer().deserialize(symbolJson.getObjectMember("type"));
   }
 }

monticore-grammar/src/main/java/de/monticore/types/check/CompKindExpression.java

@@ -74,25 +74,25 @@ public void bindParams() {
     LinkedHashMap<VariableSymbol, ASTExpression> parameterBindings = new LinkedHashMap<>();
     // We know LinkedHashMaps are ordered by insertion time. As we rely on the fact that the ordering of the
     // arguments is consistent with the ordering in the map, the following iteration ensures it:
-    for (int i = 0; i < this.getTypeInfo().getParameters().size(); i++) {
+    for (int i = 0; i < this.getTypeInfo().getParameterList().size(); i++) {
       if (i < parameterArguments.size()) // Deal with wrong number of parameters through cocos
         if (parameterArguments.get(i) instanceof ASTAssignmentExpression
           && ((ASTAssignmentExpression) parameterArguments.get(i)).getLeft() instanceof ASTNameExpression) {
           keywordExpressionMap.put(((ASTNameExpression) ((ASTAssignmentExpression) parameterArguments.get(i))
             .getLeft()).getName(), parameterArguments.get(i));
         } else {
-          parameterBindings.put(this.getTypeInfo().getParameters().get(i), parameterArguments.get(i));
+          parameterBindings.put(this.getTypeInfo().getParameterList().get(i), parameterArguments.get(i));
           firstKeywordArgument++;
         }
     }
 
     // iterate over keyword-based arguments (CoCo assures that no position-based argument occurs
     // after the first keyword-based argument)
-    for (int j = firstKeywordArgument; j < this.getTypeInfo().getParameters().size(); j++) {
-      if (keywordExpressionMap.containsKey(this.getTypeInfo().getParameters().get(j).getName()) &&
-        !parameterBindings.containsKey(this.getTypeInfo().getParameters().get(j))) {
-        parameterBindings.put(this.getTypeInfo().getParameters().get(j),
-          keywordExpressionMap.get(this.getTypeInfo().getParameters().get(j).getName()));
+    for (int j = firstKeywordArgument; j < this.getTypeInfo().getParameterList().size(); j++) {
+      if (keywordExpressionMap.containsKey(this.getTypeInfo().getParameterList().get(j).getName()) &&
+        !parameterBindings.containsKey(this.getTypeInfo().getParameterList().get(j))) {
+        parameterBindings.put(this.getTypeInfo().getParameterList().get(j),
+          keywordExpressionMap.get(this.getTypeInfo().getParameterList().get(j).getName()));
       }
     }