Merge pull request #91 from MontiCore/cd4c-lsp

Add CD4C language server

Author: ahellwig

language-server/build.gradle

@@ -72,8 +72,37 @@ task autoconfigure(type: de.mclsg.task.AutoconfigureTask) {
     including(TaskTypes.VSCODE_PLUGIN)
   }
 }
+
+task autoconfigureCD4Code(type: de.mclsg.task.AutoconfigureTask) {
+  mclsg {
+    languageName = "de.monticore.CD4Code"
+    fileExtension = "cd"
+  }
+  if(("true").equals(getProperty('buildVscodePlugin'))){
+    including(TaskTypes.VSCODE_PLUGIN)
+  }
+}
+
 compileJava.dependsOn autoconfigure
+compileJava.dependsOn autoconfigureCD4Code
+
+packCD4AnalysisLanguageServer {
+  getArchiveBaseName().set("cd4a-language-server")
+}
+
+packCD4CodeLanguageServer {
+  getArchiveBaseName().set("cd4c-language-server")
+}
 
 tasks.generateCD4AnalysisLanguageServer.dependsOn(project(":cdlang").tasks.grammarsJar)
 tasks.generateCD4AnalysisLanguageServer.dependsOn(project(":cdlang").tasks.grammarsForVariantJar)
 tasks.packCD4AnalysisLanguageServer.dependsOn(project(":cdlang").tasks.jar)
+
+tasks.generateCD4CodeLanguageServer.dependsOn(project(":cdlang").tasks.grammarsJar)
+tasks.generateCD4CodeLanguageServer.dependsOn(project(":cdlang").tasks.grammarsForVariantJar)
+tasks.packCD4CodeLanguageServer.dependsOn(project(":cdlang").tasks.jar)
+
+if(("true").equals(getProperty('buildVscodePlugin'))) {
+  tasks.buildCD4CodeVscodePlugin.dependsOn(tasks.packageCD4CodeVscodePlugin)
+  tasks.buildCD4AnalysisVscodePlugin.dependsOn(tasks.packageCD4AnalysisVscodePlugin)
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/CD4CodeLanguageServer.java

@@ -0,0 +1,35 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp;
+
+import de.mclsg.lsp.modelpath.multiproject.ProjectLayout;
+import de.mclsg.lsp.ISymbolUsageResolutionProvider;
+import de.mclsg.lsp.document_management.DocumentManager;
+import de.monticore.cd4code._lsp.features.code_action.CD4CodeCodeActionProvider;
+import de.monticore.cd4analysis._lsp.features.code_action.CollapseHierarchyCodeActionStrategy;
+import de.monticore.cd4analysis._lsp.features.code_action.ExtractSuperClassCodeActionStrategy;
+import de.monticore.cd4analysis._lsp.features.code_action.PullUpFieldCodeActionStrategy;
+import de.monticore.cd4analysis._lsp.features.code_action.UnfoldByAttributesStrategy;
+import de.monticore.cd4code._lsp.language_access.CD4CodeScopeManager;
+
+public class CD4CodeLanguageServer extends CD4CodeLanguageServerTOP {
+  
+  public CD4CodeLanguageServer(DocumentManager documentManager, ProjectLayout layout,
+      CD4CodeScopeManager scopeManager,
+      ISymbolUsageResolutionProvider symbolUsageResolutionProvider) {
+    super(documentManager, layout, scopeManager, symbolUsageResolutionProvider);
+    
+    CD4CodeCodeActionProvider codeActionProvider = new CD4CodeCodeActionProvider(documentManager,
+        languageAccess.getPrettyPrinter().orElseThrow());
+    codeActionProvider.addCodeActionStrategy(new PullUpFieldCodeActionStrategy(documentManager,
+        symbolUsageResolutionProvider, languageAccess.getPrettyPrinter().orElseThrow()));
+    codeActionProvider.addCodeActionStrategy(new ExtractSuperClassCodeActionStrategy(
+        documentManager, languageAccess.getPrettyPrinter().orElseThrow()));
+    codeActionProvider.addCodeActionStrategy(new CollapseHierarchyCodeActionStrategy(
+        documentManager, languageAccess.getPrettyPrinter().orElseThrow(),
+        symbolUsageResolutionProvider));
+    codeActionProvider.addCodeActionStrategy(new UnfoldByAttributesStrategy(documentManager,
+        languageAccess.getPrettyPrinter().orElseThrow()));
+    textDocumentService.register(codeActionProvider);
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/CD4CodeTextDocumentService.java

@@ -0,0 +1,27 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp;
+
+import de.mclsg.lsp.CommonLanguageServer;
+import de.mclsg.lsp.ISymbolUsageResolutionProvider;
+import de.mclsg.lsp.document_management.DocumentManager;
+import de.monticore.cd4code._lsp.features.code_lens.CD4CodeCodeLensProvider;
+import de.monticore.cd4code._lsp.language_access.CD4CodeLanguageAccess;
+import org.eclipse.lsp4j.services.LanguageClient;
+
+public class CD4CodeTextDocumentService extends CD4CodeTextDocumentServiceTOP {
+  
+  public CD4CodeTextDocumentService(CommonLanguageServer languageServer,
+      DocumentManager documentManager, LanguageClient languageClient,
+      CD4CodeLanguageAccess languageAccess,
+      ISymbolUsageResolutionProvider symbolUsageResolutionProvider) {
+    super(languageServer, documentManager, languageClient, languageAccess,
+        symbolUsageResolutionProvider);
+  }
+  
+  @Override
+  protected void registerDefaultCodeLensProvider() {
+    register(new CD4CodeCodeLensProvider(referencesProvider, documentManager,
+        symbolUsageResolutionProvider));
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/features/code_action/CD4CodeCodeActionProvider.java

@@ -0,0 +1,42 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp.features.code_action;
+
+import de.mclsg.lsp.document_management.DocumentManager;
+import de.monticore.cd4analysis._lsp.features.code_action.CodeActionStrategy;
+import de.monticore.cdbasis._ast.ASTCDCompilationUnit;
+import de.monticore.prettyprint.AstPrettyPrinter;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.lsp4j.CodeAction;
+import org.eclipse.lsp4j.CodeActionContext;
+import org.eclipse.lsp4j.Command;
+import org.eclipse.lsp4j.Range;
+import org.eclipse.lsp4j.TextDocumentItem;
+import org.eclipse.lsp4j.jsonrpc.messages.Either;
+
+public class CD4CodeCodeActionProvider extends CD4CodeCodeActionProviderTOP {
+  
+  private final List<CodeActionStrategy> strategies;
+  
+  public CD4CodeCodeActionProvider(DocumentManager documentManager,
+      AstPrettyPrinter<ASTCDCompilationUnit> prettyPrinter) {
+    super(documentManager, prettyPrinter);
+    this.strategies = new ArrayList<>();
+  }
+  
+  public void addCodeActionStrategy(CodeActionStrategy codeActionStrategy) {
+    strategies.add(codeActionStrategy);
+  }
+  
+  @Override
+  public List<Either<Command, CodeAction>> codeAction(TextDocumentItem document,
+      CodeActionContext context, Range range) {
+    List<Either<Command, CodeAction>> baseActions = super.codeAction(document, context, range);
+    
+    strategies.stream().flatMap(strategy -> strategy.apply(document, context, range).stream())
+        .forEach(baseActions::add);
+    
+    return baseActions;
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/features/code_lens/CD4CodeCodeLensProvider.java

@@ -0,0 +1,52 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp.features.code_lens;
+
+import de.mclsg.lsp.ISymbolUsageResolutionProvider;
+import de.mclsg.lsp.document_management.DocumentInformation;
+import de.mclsg.lsp.document_management.DocumentManager;
+import de.mclsg.lsp.features.code_lens.CodeLensStrategy;
+import de.mclsg.lsp.features.reference.CommonReferencesProvider;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import de.monticore.cd4analysis._lsp.features.code_lens.AssociationCodeLensStrategy;
+import org.eclipse.lsp4j.CodeLens;
+import org.eclipse.lsp4j.TextDocumentItem;
+
+public class CD4CodeCodeLensProvider extends CD4CodeCodeLensProviderTOP {
+  
+  private final DocumentManager documentManager;
+  
+  public CD4CodeCodeLensProvider(DocumentManager documentManager) {
+    super(documentManager);
+    throw new IllegalStateException();
+  }
+  
+  public CD4CodeCodeLensProvider(CommonReferencesProvider referencesProvider,
+      DocumentManager documentManager,
+      ISymbolUsageResolutionProvider symbolUsageResolutionProvider) {
+    super(documentManager);
+    this.documentManager = documentManager;
+    this.strategyManager.registerCodeLensStrategy(new AssociationCodeLensStrategy(
+        referencesProvider, documentManager, symbolUsageResolutionProvider));
+  }
+  
+  public void registerCodeLensStrategy(CodeLensStrategy codeLensStrategy) {
+    strategyManager.registerCodeLensStrategy(codeLensStrategy);
+  }
+  
+  @Override
+  public List<? extends CodeLens> codeLens(TextDocumentItem document) {
+    Optional<DocumentInformation> documentInformation = documentManager.getDocumentInformation(
+        document);
+    if (documentInformation.isEmpty())
+      return List.of();
+    
+    return documentInformation.get().getMatchedNameTokens().stream().map(
+        matchedToken -> strategyManager.getCodeLensStrategies(matchedToken).stream().map(
+            codeLensStrategy -> codeLensStrategy.apply(matchedToken)).flatMap(Optional::stream)
+            .collect(Collectors.toList())).flatMap(List::stream).collect(Collectors.toList());
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/features/code_lens/CD4CodeServerCommandCodeLens.java

@@ -0,0 +1,16 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp.features.code_lens;
+
+import java.util.List;
+import org.eclipse.lsp4j.CodeLens;
+import org.eclipse.lsp4j.Command;
+import org.eclipse.lsp4j.Range;
+
+public class CD4CodeServerCommandCodeLens extends CodeLens {
+  
+  public CD4CodeServerCommandCodeLens(Range range, String title, String command,
+      List<Object> arguments) {
+    super(range, new Command(title, command, arguments), null);
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/language_access/CD4CodeAstPrettyPrinter.java

@@ -0,0 +1,19 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp.language_access;
+
+import de.monticore.cd4code._prettyprint.CD4CodeFullPrettyPrinter;
+import de.monticore.cdbasis._ast.ASTCDCompilationUnit;
+import de.monticore.prettyprint.AstPrettyPrinter;
+import de.monticore.prettyprint.IndentPrinter;
+
+public class CD4CodeAstPrettyPrinter implements AstPrettyPrinter<ASTCDCompilationUnit> {
+  
+  private final CD4CodeFullPrettyPrinter prettyPrinter = new CD4CodeFullPrettyPrinter(
+      new IndentPrinter());
+  
+  @Override
+  public String prettyPrint(ASTCDCompilationUnit node) {
+    return prettyPrinter.prettyprint(node);
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/language_access/CD4CodeLanguageAccess.java

@@ -0,0 +1,23 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp.language_access;
+
+import de.mclsg.lsp.document_management.DocumentManager;
+import de.monticore.cdbasis._ast.ASTCDCompilationUnit;
+import de.monticore.prettyprint.AstPrettyPrinter;
+import java.util.Optional;
+
+public class CD4CodeLanguageAccess extends CD4CodeLanguageAccessTOP {
+  
+  private final CD4CodeAstPrettyPrinter prettyPrinter;
+  
+  public CD4CodeLanguageAccess(DocumentManager documentManager, CD4CodeScopeManager scopeManager) {
+    super(documentManager, scopeManager);
+    this.prettyPrinter = new CD4CodeAstPrettyPrinter();
+  }
+  
+  @Override
+  public Optional<AstPrettyPrinter<ASTCDCompilationUnit>> getPrettyPrinter() {
+    return Optional.of(prettyPrinter);
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/language_access/CD4CodeLspCoCoRunner.java

@@ -0,0 +1,29 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp.language_access;
+
+import de.mclsg.lsp.document_management.DocumentManager;
+import de.monticore.cd4code._cocos.CD4CodeCoCoChecker;
+import de.monticore.cd4code.cocos.CD4CodeCoCosDelegator;
+import de.monticore.cdbasis._ast.ASTCDCompilationUnit;
+
+public class CD4CodeLspCoCoRunner extends CD4CodeLspCoCoRunnerTOP {
+  
+  private CD4CodeCoCoChecker checker;
+  
+  public CD4CodeLspCoCoRunner(DocumentManager documentManager) {
+    super(documentManager);
+    CD4CodeCoCosDelegator cd4CodeCoCos = new CD4CodeCoCosDelegator();
+    checker = cd4CodeCoCos.getCheckerForAllCoCos();
+  }
+  
+  @Override
+  public boolean needsSymbols() {
+    return true;
+  }
+  
+  @Override
+  public void runAllCoCos(ASTCDCompilationUnit ast) {
+    checker.checkAll(ast);
+  }
+  
+}

language-server/src/main/java/de/monticore/cd4code/_lsp/language_access/CD4CodeScopeManager.java

@@ -0,0 +1,66 @@
+/* (c) https://github.com/MontiCore/monticore */
+package de.monticore.cd4code._lsp.language_access;
+
+import de.monticore.cd._symboltable.BuiltInTypes;
+import de.monticore.cd4code._symboltable.CD4CodeSymbolTableCompleter;
+import de.monticore.cd4code._symboltable.ICD4CodeArtifactScope;
+import de.monticore.cd4code.trafo.CD4CodeDirectCompositionTrafo;
+import de.monticore.cdbasis._ast.ASTCDCompilationUnit;
+import de.monticore.io.paths.MCPath;
+import de.monticore.symbols.basicsymbols.BasicSymbolsMill;
+import de.se_rwth.commons.logging.Log;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class CD4CodeScopeManager extends CD4CodeScopeManagerTOP {
+  
+  @Override
+  public void initGlobalScope(MCPath modelPath) {
+    super.initGlobalScope(modelPath);
+    syncAccessGlobalScope(gs -> {
+      BuiltInTypes.addBuiltInTypes(gs);
+      BasicSymbolsMill.initializeString();
+    });
+  }
+  
+  @Override
+  public CD4CodeArtifactScopeWithFindings createArtifactScope(ASTCDCompilationUnit ast,
+      ICD4CodeArtifactScope old) {
+    // Apply transformations required after parsing
+    new CD4CodeDirectCompositionTrafo().transform(ast);
+    
+    CD4CodeArtifactScopeWithFindings res = super.createArtifactScope(ast, old);
+    ast.accept(new CD4CodeSymbolTableCompleter(ast).getTraverser());
+    res.findings.addAll(Log.getFindings());
+    
+    return res;
+  }
+  
+  @Override
+  public Map<ASTCDCompilationUnit, CD4CodeArtifactScopeWithFindings> createAllArtifactScopes(
+      Collection<ASTCDCompilationUnit> astNodes) {
+    final Map<ASTCDCompilationUnit, CD4CodeArtifactScopeWithFindings> res = new LinkedHashMap<>();
+    syncAccessGlobalScope(gs -> {
+      clearGlobalScope();
+      if (supportsIterativeScopeAppending()) {
+        for (ASTCDCompilationUnit node : astNodes) {
+          Log.getFindings().clear();
+          // Apply transformations
+          new CD4CodeDirectCompositionTrafo().transform(node);
+          // Use super.createArtifactScope, so that the completer is not used
+          res.put(node, super.createArtifactScope(node, null));
+        }
+        
+        // Phase 2: complete symbol table when base structure is finished
+        for (ASTCDCompilationUnit ast : astNodes) {
+          Log.getFindings().clear();
+          ast.accept(new CD4CodeSymbolTableCompleter(ast).getTraverser());
+          res.get(ast).findings.addAll(Log.getFindings());
+        }
+      }
+    });
+    return res;
+  }
+  
+}