Error logging if subcomponent is of primitive type

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

@@ -3,6 +3,7 @@
 
 import de.monticore.types.mcbasictypes._ast.ASTMCType;
 import de.monticore.types.mcbasictypes._visitor.MCBasicTypesTraverser;
+import de.se_rwth.commons.logging.Log;
 import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.util.Optional;
@@ -30,6 +31,12 @@ public interface ISynthesizeComponent {
   default Optional<CompKindExpression> synthesize(@NonNull ASTMCType mcType) {
     this.init();
     mcType.accept(this.getTraverser());
-    return this.getResult();
+    Optional<CompKindExpression> res = this.getResult();
+    if (res.isEmpty()) {
+      Log.error(String.format("0xD0104 Cannot resolve component '%s'", mcType.toString()),
+        mcType.get_SourcePositionStart(), mcType.get_SourcePositionEnd()
+      );
+    }
+    return res;
   }
 }

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

@@ -50,9 +50,6 @@ public void handle(@NonNull ASTMCQualifiedType node) {
     List<ComponentTypeSymbol> comp = enclScope.resolveComponentTypeMany(node.getMCQualifiedName().getQName());
 
     if (comp.isEmpty()) {
-      Log.error(String.format("0xD0104 Cannot resolve component '%s'", node.getMCQualifiedName().getQName()),
-        node.get_SourcePositionStart(), node.get_SourcePositionEnd()
-      );
       this.resultWrapper.setResultAbsent();
     } else {
       CompKindExpression result = new CompKindOfComponentType(comp.get(0));

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

@@ -57,9 +57,6 @@ public void handle(@NonNull ASTMCBasicGenericType mcType) {
     List<ComponentTypeSymbol> compSym = enclScope.resolveComponentTypeMany(compName);
 
     if (compSym.isEmpty()) {
-      Log.error(String.format("0xD0104 Cannot resolve component '%s'", mcType.getNameList().stream().reduce("", String::concat)),
-          mcType.get_SourcePositionStart(), mcType.get_SourcePositionEnd()
-      );
       this.resultWrapper.setResultAbsent();
     } else {
       if (compSym.size() > 1) {

monticore-grammar/src/test/grammars/de/monticore/types/ComponentSymbolsWithMCBasicTypesTest.mc4

@@ -0,0 +1,10 @@
+/* (c) https://github.com/MontiCore/monticore */
+
+package de.monticore.types;
+
+component grammar ComponentSymbolsWithMCBasicTypesTest extends
+          de.monticore.symbols.CompSymbols,
+          de.monticore.symbols.OOSymbols,
+          de.monticore.types.MCBasicTypes,
+          de.monticore.types.MCSimpleGenericTypes {
+}

monticore-grammar/src/test/java/de/monticore/types/check/FullSynthesizeCompKindFromMCBasicTypesTest.java

@@ -0,0 +1,67 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.types.check;
+
+import de.monticore.runtime.junit.AbstractMCTest;
+import de.monticore.runtime.junit.MCAssertions;
+import de.monticore.symbols.compsymbols._symboltable.ComponentTypeSymbol;
+import de.monticore.types.MCTypeFacade;
+import de.monticore.types.componentsymbolswithmcbasictypestest.ComponentSymbolsWithMCBasicTypesTestMill;
+import de.monticore.types.mcbasictypes._ast.ASTMCType;
+import de.se_rwth.commons.logging.Log;
+import de.se_rwth.commons.logging.LogStub;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+public class FullSynthesizeCompKindFromMCBasicTypesTest extends AbstractMCTest {
+
+  @BeforeEach
+  public void setup() {
+    LogStub.init();
+    Log.enableFailQuick(false);
+    Log.clearFindings();
+
+    ComponentSymbolsWithMCBasicTypesTestMill.reset();
+    ComponentSymbolsWithMCBasicTypesTestMill.init();
+  }
+
+  @Test
+  public void synthesizesCompKind_forResolvableComponentTypeSymbol() {
+    // Given
+    ComponentTypeSymbol typeA = ComponentSymbolsWithMCBasicTypesTestMill.componentTypeSymbolBuilder()
+      .setName("A")
+      .setSpannedScope(ComponentSymbolsWithMCBasicTypesTestMill.scope())
+      .build();
+    ComponentSymbolsWithMCBasicTypesTestMill.globalScope().add(typeA);
+    typeA.setEnclosingScope(ComponentSymbolsWithMCBasicTypesTestMill.globalScope());
+
+    ASTMCType ast = MCTypeFacade.getInstance().createQualifiedType("A");
+    ast.setEnclosingScope(ComponentSymbolsWithMCBasicTypesTestMill.globalScope());
+
+    FullSynthesizeCompKindFromMCBasicTypes synth = new FullSynthesizeCompKindFromMCBasicTypes();
+
+    // When
+    Optional<CompKindExpression> res = synth.synthesize(ast);
+
+    // Then
+    Assertions.assertTrue(res.isPresent());
+    Assertions.assertTrue(res.get().isComponentType());
+    Assertions.assertEquals(typeA, res.get().getTypeInfo());
+  }
+
+  @Test
+  public void shouldLogErrorOnPrimitive() {
+    // Given
+    ASTMCType ast = MCTypeFacade.getInstance().createIntType();
+    FullSynthesizeCompKindFromMCBasicTypes synth = new FullSynthesizeCompKindFromMCBasicTypes();
+
+    // When
+    Optional<CompKindExpression> result = synth.synthesize(ast);
+
+    // Then
+    Assertions.assertTrue(result.isEmpty(), "Expected no CompKindExpression for primitive 'int'");
+    MCAssertions.assertHasFindingStartingWith("0xD0104");
+  }
+}

monticore-grammar/src/test/java/de/monticore/types/check/SynthesizeComponentFromMCBasicTypesTest.java

@@ -0,0 +1,139 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.types.check;
+
+import de.monticore.runtime.junit.AbstractMCTest;
+import de.monticore.runtime.junit.MCAssertions;
+import de.monticore.symbols.compsymbols._symboltable.ComponentTypeSymbol;
+import de.monticore.types.MCTypeFacade;
+import de.monticore.types.componentsymbolswithmcbasictypestest.ComponentSymbolsWithMCBasicTypesTestMill;
+import de.monticore.types.componentsymbolswithmcbasictypestest._visitor.ComponentSymbolsWithMCBasicTypesTestTraverser;
+import de.monticore.types.mcbasictypes._ast.ASTMCQualifiedType;
+import de.monticore.types.mcbasictypes._ast.ASTMCVoidType;
+import de.se_rwth.commons.logging.Log;
+import de.se_rwth.commons.logging.LogStub;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+public class SynthesizeComponentFromMCBasicTypesTest extends AbstractMCTest {
+
+  @BeforeEach
+  public void setup() {
+    LogStub.init();
+    Log.enableFailQuick(false);
+    Log.clearFindings();
+
+    ComponentSymbolsWithMCBasicTypesTestMill.reset();
+    ComponentSymbolsWithMCBasicTypesTestMill.init();
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {"Foo", "qual.Foo"})
+  public void shouldHandleMCQualifiedType(String qualifiedCompName) {
+    var globalScope = ComponentSymbolsWithMCBasicTypesTestMill.globalScope();
+
+    ASTMCQualifiedType ast = MCTypeFacade.getInstance().createQualifiedType(qualifiedCompName);
+    ast.setEnclosingScope(globalScope);
+
+    ComponentTypeSymbol symbol = ComponentSymbolsWithMCBasicTypesTestMill.componentTypeSymbolBuilder()
+      .setName(ast.getMCQualifiedName().getBaseName())
+      .setSpannedScope(ComponentSymbolsWithMCBasicTypesTestMill.scope())
+      .build();
+
+    if (qualifiedCompName.equals("qual.Foo")) {
+      var qualScope = ComponentSymbolsWithMCBasicTypesTestMill.scope();
+      qualScope.setName("qual");
+      qualScope.add(symbol);
+      qualScope.addSubScope(symbol.getSpannedScope());
+      globalScope.addSubScope(qualScope);
+    } else {
+      globalScope.add(symbol);
+      globalScope.addSubScope(symbol.getSpannedScope());
+    }
+
+    CompKindCheckResult result = new CompKindCheckResult();
+    SynthesizeCompKindFromMCBasicTypes synth =
+      new SynthesizeCompKindFromMCBasicTypes(result);
+
+    // When
+    synth.handle(ast);
+
+    // Then
+    Assertions.assertTrue(result.getResult().isPresent());
+    Assertions.assertTrue(result.getResult().get().isComponentType());
+    Assertions.assertEquals(symbol, result.getResult().get().getTypeInfo());
+  }
+
+  @Test
+  public void shouldLogErrorForDuplicateSymbols() {
+    // Given
+    ASTMCQualifiedType ast = MCTypeFacade.getInstance().createQualifiedType("Foo");
+    ast.setEnclosingScope(ComponentSymbolsWithMCBasicTypesTestMill.globalScope());
+
+
+    ComponentTypeSymbol compSymbol1 = ComponentSymbolsWithMCBasicTypesTestMill.componentTypeSymbolBuilder()
+      .setName(ast.getMCQualifiedName().getBaseName())
+      .setSpannedScope(ComponentSymbolsWithMCBasicTypesTestMill.scope())
+      .build();
+    ComponentSymbolsWithMCBasicTypesTestMill.globalScope().add(compSymbol1);
+    ComponentSymbolsWithMCBasicTypesTestMill.globalScope().addSubScope(compSymbol1.getSpannedScope());
+
+    ComponentTypeSymbol compSymbol2 = ComponentSymbolsWithMCBasicTypesTestMill.componentTypeSymbolBuilder()
+      .setName(ast.getMCQualifiedName().getBaseName())
+      .setSpannedScope(ComponentSymbolsWithMCBasicTypesTestMill.scope())
+      .build();
+    ComponentSymbolsWithMCBasicTypesTestMill.globalScope().add(compSymbol2);
+    ComponentSymbolsWithMCBasicTypesTestMill.globalScope().addSubScope(compSymbol2.getSpannedScope());
+
+    CompKindCheckResult result = new CompKindCheckResult();
+    SynthesizeCompKindFromMCBasicTypes synth = new SynthesizeCompKindFromMCBasicTypes(result);
+
+    // When
+    synth.handle(ast);
+
+    // Then
+    Assertions.assertTrue(result.getResult().isPresent());
+    Assertions.assertTrue(result.getResult().get().isComponentType());
+    Assertions.assertEquals(compSymbol1, result.getResult().get().getTypeInfo());
+    MCAssertions.assertHasFindingStartingWith("0xD0105");
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {"Foo", "qual.Foo"})
+  public void shouldNotLogErrorForMissingSymbol(String qualifiedName) {
+    // Given
+    ASTMCQualifiedType astNormalComp = MCTypeFacade.getInstance().createQualifiedType(qualifiedName);
+    astNormalComp.setEnclosingScope(ComponentSymbolsWithMCBasicTypesTestMill.globalScope());
+
+    CompKindCheckResult result = new CompKindCheckResult();
+    SynthesizeCompKindFromMCBasicTypes synth4normal = new SynthesizeCompKindFromMCBasicTypes(result);
+
+    // When
+    synth4normal.handle(astNormalComp);
+
+    // Then
+    Assertions.assertFalse(result.getResult().isPresent());
+  }
+
+  @Test
+  public void shouldNotHandleVoidType() {
+    // Given
+    ASTMCVoidType voidType = ComponentSymbolsWithMCBasicTypesTestMill.mCVoidTypeBuilder().build();
+    CompKindCheckResult resultWrapper = new CompKindCheckResult();
+    SynthesizeCompKindFromMCBasicTypes synth = new SynthesizeCompKindFromMCBasicTypes(resultWrapper);
+
+    // Attach a traverser to the synth, as we do not override the handle method and thus the synth tries to traverse the
+    // AST. In the end this should result in an empty synth result, however, if we do not attach a traverser, this will
+    // Result in an error instead.
+    ComponentSymbolsWithMCBasicTypesTestTraverser traverser = ComponentSymbolsWithMCBasicTypesTestMill.traverser();
+    traverser.setMCBasicTypesHandler(synth);
+
+    // When
+    synth.handle(voidType);
+
+    // Then
+    Assertions.assertFalse(resultWrapper.getResult().isPresent());
+  }
+}