Ln/calc def as function symbol

build.gradle

@@ -6,7 +6,7 @@ subprojects {
   group = 'de.monticore.lang.sysml_v2'
 
   // Needs to be after java plugin
-  sourceCompatibility = "11"
+  sourceCompatibility = JavaVersion.VERSION_11
 
   project.buildDir = "target"
 
@@ -19,8 +19,12 @@ subprojects {
   }
 
   // Java JDK Warning
-  if (JavaVersion.current() > sourceCompatibility) {
-    logger.warn("\u001B[33m Warning: You are currently using JDK Version " + JavaVersion.current() + ". " + "Higher JDK versions may cause compatibility problems. JDK 11 is recommended. \u001B[0m")
+  if (JavaVersion.current() > sourceCompatibility
+      && JavaVersion.current() != JavaVersion.VERSION_17)
+  {
+    logger.warn("\u001B[33m Warning: You are currently using JDK Version " +
+        JavaVersion.current() + ". " + "Higher JDK versions may cause " +
+        "compatibility problems. JDK 11 or 17 is recommended. \u001B[0m")
   }
 
   // Use the same testing framework for all modules

cc/src/main/grammars/de/monticore/lang/ComponentConnector.mc4

@@ -156,4 +156,22 @@ component grammar ComponentConnector
     transitions: Transition*
   ;
 
+  /**
+   * Requirements: Wir berücksichtigen primär die Namen der Requirements
+   */
+   interface symbol Requirement =
+     name:Name
+     [isStateInvariant:"invariant"]?
+     subject:MildComponent
+     assumptions:Expression*
+     guarantee:Expression
+   ;
+
+   symbolrule Requirement =
+      stateInvariant: boolean
+      subject:MildComponentSymbol
+      assumptions:Expression*
+      guarantee:Expression
+   ;
+
 }

cc/src/main/java/de/monticore/lang/componentconnector/_symboltable/RequirementSymbolDeSer.java

@@ -0,0 +1,45 @@
+package de.monticore.lang.componentconnector._symboltable;
+
+import de.monticore.expressions.expressionsbasis._ast.ASTExpression;
+import de.monticore.symboltable.serialization.json.JsonObject;
+
+import java.util.List;
+
+public class RequirementSymbolDeSer extends RequirementSymbolDeSerTOP {
+
+  @Override
+  protected void serializeSubject(MildComponentSymbol subject,
+                                  ComponentConnectorSymbols2Json s2j) {
+    // not implemented
+  }
+
+  @Override
+  protected void serializeAssumptions(List<ASTExpression> assumptions,
+                                      ComponentConnectorSymbols2Json s2j) {
+    // not implemented
+  }
+
+  @Override
+  protected void serializeGuarantee(ASTExpression guarantee,
+                                    ComponentConnectorSymbols2Json s2j) {
+    // not implemented
+  }
+
+  @Override
+  protected MildComponentSymbol deserializeSubject(JsonObject symbolJson) {
+    // not implemented
+    return null;
+  }
+
+  @Override
+  protected List<ASTExpression> deserializeAssumptions(JsonObject symbolJson) {
+    // not implemented
+    return List.of();
+  }
+
+  @Override
+  protected ASTExpression deserializeGuarantee(JsonObject symbolJson) {
+    // not implemented
+    return null;
+  }
+}

doc/ImporteUndResolvingDocs.md

@@ -0,0 +1,89 @@
+# Dokumentation: Import-Mechanismus und Namensauflösung
+In der MontiCore-basierten Implementierung von SysMLv2 ist die effiziente
+Auflösung von Symbolen über Modellgrenzen hinweg entscheidend. Da Modelle in der
+Regel in Pakete unterteilt sind, benötigt der `SysML-Scope` einen Mechanismus,
+um lokale Referenzen auf externe Symbole (Cross-References) auch auf Basis der
+im Scope vorhandenen Importen korrekt zuzuordnen.
+
+## 1. SysMLv2 Import-Typen
+SysMLv2 definiert verschiedene Strategien, um Elemente aus anderen Namensräumen
+verfügbar zu machen. In unserer aktuellen Implementierung werden diese wie folgt
+auf die MontiCore-Symboltabelle abgebildet:
+
+### Normaler Import
+Ein expliziter Import eines einzelnen Elements.
+* **Syntax:** `import MyPackage::MyPart;`
+* **Verhalten:** Nur das spezifische Symbol `MyPart` wird im lokalen Scope unter \
+  seinem einfachen Namen bekannt gemacht.
+
+### Wildcard Import (*)
+Importiert alle direkt in einem Paket enthaltenen Elemente.
+* **Syntax:** `import MyPackage::*;`
+* **Verhalten:** Alle Symbole, die sich unmittelbar in `MyPackage` befinden, \
+  können ohne Qualifizierung angesprochen werden.
+
+### Rekursiver Import (**)
+Importiert die gesamte Hierarchie eines Pakets inklusive aller Unterpakete.
+* **Syntax:** `import MyPackage::**;`
+* **Aktueller Status:** In der aktuellen Version werden rekursive Imports
+* **wie Wildcard-Imports (*) behandelt**. Das bedeutet, dass nur die direkte \
+  Ebene unterhalb von `MyPackage` aufgelöst wird. Eine tiefe Suche durch alle \
+  Unterpakete findet derzeit nicht statt, da dies eine Anpassung des globalen \
+  Resolve-Algorithmus erfordert.
+
+### Wildcard & Rekursiv
+Wildcard und Rekursive Imports können ebenfalls gemischt werden. Jedes Sub-Paket
+von MyPackage wird hierbei rekursiv importiert.
+* **Syntax**: `import MyPackage::*::**`
+* **Aktueller Status**: Sie werden wie Wildcard-Imports behandelt
+
+## 2. Visuelle Darstellung der Sichtbarkeiten
+Das folgende Diagramm illustriert, welche Elemente je nach Import-Strategie für
+den aktuellen Scope "sichtbar" werden:
+![SysML-Import-Typen-Visualisiert](sysmlv2-imports.png)
+
+## 3. Technische Umsetzung im SysMLv2-Scope
+Die Namensauflösung basiert auf der Delegation eines SysML-Scopes an seinen
+umschließenden-Scope. Diese delegation erfolgt innerhalb der Funktion
+continueXXXWithEnclosing Scope. Das Import-Unterstützte resolving ist hierbei
+für Variablen, Typen und Funktionen implementiert.
+
+### Die Methode `continuePartDefWithEnclosingScope`
+Wenn ein Symbol (Variablen, Typen oder Funktionen) lokal nicht gefunden wird,
+ruft MontiCore diese Methode auf. Sie berechnet eine Menge von voll-qualifizierten
+Namen (FQNs), nach denen im umschließendem Scope gesucht werden. Gesucht wird
+hierbei nach dem Namen selbst, dem Namen innerhalb des aktuellen Pakets,
+und dem Namen in allen spezifizierten Imports
+
+### Namensqualifizierung mit `calculateQualifiedNames`
+Diese Methode nutzt die im `ASTSysMLScope` hinterlegten `SysMLImportStatements`.
+Sie prüft für jeden Import:
+1.  **Bei Wildcards:** Ist der gesuchte Name ein Kind des importierten Pakets? \
+    (z.B. `ImportPfad + "." + gesuchterName`)
+2.  **Bei expliziten Importen:** Entspricht der einfache Name des Imports dem \
+    gesuchten Namen?
+
+```java
+// Logik-Ausschnitt aus der Generierung
+for (ImportStatement importStatement : imports) {
+  if (importStatement.isStar()) {
+    potentialSymbolNames.add(importStatement.getStatement() + "." + name);
+  } else if (getSimpleName(importStatement.getStatement()).equals(name)) {
+    potentialSymbolNames.add(importStatement.getStatement());
+  }
+}
+```
+
+### SysMLv2ScopesGenitor
+Die Symbole der SysML-Scopes werden aktuell nicht mit den Importen initialisiert.
+
+## 4. Einschränkungen und Roadmap
+Da `calculateQualifiedNames` in aktuellen MontiCore-Versionen als `@deprecated`
+markiert ist, sollte langfristig auf eine explizite Qualifizierung während der
+Symbolerstellung im `ScopesGenitor` umgestellt werden.
+
+**Rekursive Imports:** Um `**` korrekt zu unterstützen, muss die Logik so
+erweitert werden, dass bei Vorhandensein eines rekursiven Imports der
+`GlobalScope` angewiesen wird, eine Präfix-Suche durchzuführen, anstatt nur
+nach exakten FQNs zu suchen. Alternativ könnte hierfür auch eine iteration der
+Sub-Pakete in calculateQualifiedNames angestrebt werden.

gradle.properties

@@ -19,10 +19,10 @@ sysmlGitlab        = https://git.rwth-aachen.de/api/v4/projects/37093/packages/m
 
 # Dependencies
 mc_version         = 7.8.0
-mclsg_version      = 7.8.0
+mclsg_version      = 7.8.5
 se_commons_version = 7.8.0
 assertj_version    = 3.21.0
 junit_version      = 5.8.2
 
 # Version of published artifacts
-version            = 7.8.0
+version            = 7.8.41

language-server/src/main/java/de/monticore/lang/sysmlv2/_lsp/SysMLv2LanguageServer.java

@@ -5,6 +5,7 @@
 import de.mclsg.lsp.document_management.DocumentManager;
 import de.mclsg.lsp.modelpath.multiproject.ProjectLayoutBuilder;
 import de.monticore.lang.sysmlv2._lsp.language_access.SysMLv2ScopeManager;
+import org.eclipse.lsp4j.InitializedParams;
 import org.eclipse.lsp4j.MessageParams;
 import org.eclipse.lsp4j.MessageType;
 import org.slf4j.Logger;
@@ -17,6 +18,21 @@ public class SysMLv2LanguageServer extends SysMLv2LanguageServerTOP {
 
   private static final Logger logger = LoggerFactory.getLogger(SysMLv2LanguageServer.class);
 
+  @Override
+  public void initialized(InitializedParams params) {
+    if (options != null) {
+      // Re-resolve layout with correct workspace path
+      ProjectLayout newLayout = new ProjectLayoutBuilder()
+          .projectpath(options.getWorkspacePath())
+          .symbolPath(options.getSymbolPaths())
+          .resources(options.getModelPaths())
+          .build();
+
+      resetContent(newLayout);
+    }
+    super.initialized(params);
+  }
+
   /** Convenience: Wir modifizieren aktuell eigentlich nur den ModelPath */
   public SysMLv2LanguageServer(ProjectLayout layout) {
     this(

language-server/src/main/java/de/monticore/lang/sysmlv2/_lsp/features/code_action/SysMLv2CodeActionProvider.java

@@ -18,6 +18,7 @@ public SysMLv2CodeActionProvider(DocumentManager documentManager,
                                    AstPrettyPrinter<ASTSysMLModel> astSysMLModelAstPrettyPrinter) {
     super(documentManager, astSysMLModelAstPrettyPrinter);
     coCoCodeActionProviders.add(new UpperCaseBlockName(documentManager));
+    coCoCodeActionProviders.add(new UniqueSubPartName(documentManager));
     coCoCodeActionProviders.add(new MissingRefinement(documentManager));
     coCoCodeActionProviders.add(new MissingRefiner(documentManager));
   }