fix: Store symbols in a repository

Store symbols in a repository, to be later used for completion, references, definition and highlights.

Signed-off-by: ap891843 <[email protected]>

Author: ap891843

server/engine/src/main/java/org/eclipse/lsp/cobol/core/engine/CobolLanguageEngine.java

@@ -45,7 +45,9 @@
 import org.eclipse.lsp.cobol.core.CobolParser;
 import org.eclipse.lsp.cobol.core.engine.dialects.DialectService;
 import org.eclipse.lsp.cobol.core.engine.processor.AstProcessor;
-import org.eclipse.lsp.cobol.core.engine.symbols.SymbolService;
+import org.eclipse.lsp.cobol.core.engine.symbols.SymbolAccumulatorService;
+import org.eclipse.lsp.cobol.core.engine.symbols.SymbolTable;
+import org.eclipse.lsp.cobol.core.engine.symbols.SymbolsRepository;
 import org.eclipse.lsp.cobol.core.model.*;
 import org.eclipse.lsp.cobol.core.model.tree.*;
 import org.eclipse.lsp.cobol.core.model.tree.logic.*;
@@ -68,9 +70,7 @@
 import org.eclipse.lsp.cobol.service.delegates.validations.AnalysisResult;
 import org.eclipse.lsp4j.Location;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
@@ -95,9 +95,10 @@ public class CobolLanguageEngine {
   private final SubroutineService subroutineService;
   private final CachingConfigurationService cachingConfigurationService;
   private final DialectService dialectService;
-  private final SymbolService symbolService;
+  private final SymbolAccumulatorService symbolAccumulatorService;
   private final AstProcessor astProcessor;
   private final InjectService injectService;
+  private final SymbolsRepository symbolsRepository;
 
   @Inject
   public CobolLanguageEngine(
@@ -107,18 +108,20 @@ public CobolLanguageEngine(
       SubroutineService subroutineService,
       CachingConfigurationService cachingConfigurationService,
       DialectService dialectService,
-      SymbolService symbolService,
+      SymbolAccumulatorService symbolAccumulatorService,
       AstProcessor astProcessor,
-      InjectService injectService) {
+      InjectService injectService,
+      SymbolsRepository symbolsRepository) {
     this.preprocessor = preprocessor;
     this.messageService = messageService;
     this.treeListener = treeListener;
     this.subroutineService = subroutineService;
     this.cachingConfigurationService = cachingConfigurationService;
     this.dialectService = dialectService;
-    this.symbolService = symbolService;
+    this.symbolAccumulatorService = symbolAccumulatorService;
     this.astProcessor = astProcessor;
     this.injectService = injectService;
+    this.symbolsRepository = symbolsRepository;
   }
 
   /**
@@ -139,7 +142,6 @@ public ResultWithErrors<AnalysisResult> run(
     Timing.Builder timingBuilder = Timing.builder();
 
     timingBuilder.getDialectsTimer().start();
-    symbolService.reset(documentUri);
     List<SyntaxError> accumulatedErrors = new ArrayList<>();
     TextTransformations cleanText =
         preprocessor.cleanUpCode(documentUri, text).unwrap(accumulatedErrors::addAll);
@@ -252,7 +254,7 @@ public ResultWithErrors<AnalysisResult> run(
             embeddedCodeParts,
             messageService,
             subroutineService,
-            symbolService,
+            symbolsRepository,
             dialectOutcome.getDialectNodes(),
             cachingConfigurationService);
     List<Node> syntaxTree = visitor.visit(tree);
@@ -290,10 +292,14 @@ public ResultWithErrors<AnalysisResult> run(
           timing.getLateErrorProcessingTime());
     }
 
+    Map<String, SymbolTable> symbolTableMap = Collections.synchronizedMap(new HashMap<>(symbolAccumulatorService.getProgramSymbols()));
+    symbolsRepository.updateSymbols(symbolTableMap);
+    symbolAccumulatorService.reset(documentUri);
+
     return new ResultWithErrors<>(
         AnalysisResult.builder()
             .rootNode(rootNode)
-            .symbolTableMap(symbolService.getProgramSymbols())
+            .symbolTableMap(symbolTableMap)
             .build(),
         accumulatedErrors.stream().map(this::constructErrorMessage).collect(toList()));
   }
@@ -307,63 +313,63 @@ private void registerProcessors(AnalysisConfig analysisConfig, ProcessingContext
         new ProcessorDescription(
             SectionNode.class,
             ProcessingPhase.TRANSFORMATION,
-            new ProcessNodeWithVariableDefinitions(symbolService)));
+            new ProcessNodeWithVariableDefinitions(symbolAccumulatorService)));
     ctx.register(
         new ProcessorDescription(
             FileEntryNode.class, ProcessingPhase.TRANSFORMATION, new FileEntryProcess()));
     ctx.register(
         new ProcessorDescription(
             FileDescriptionNode.class,
             ProcessingPhase.TRANSFORMATION,
-            new FileDescriptionProcess(symbolService)));
+            new FileDescriptionProcess(symbolAccumulatorService)));
     ctx.register(
         new ProcessorDescription(
             DeclarativeProcedureSectionNode.class,
             ProcessingPhase.TRANSFORMATION,
-            new DeclarativeProcedureSectionRegister(symbolService)));
+            new DeclarativeProcedureSectionRegister(symbolAccumulatorService, symbolsRepository)));
     // Phase DEFINITION
     ctx.register(
         new ProcessorDescription(
-            ParagraphsNode.class, ProcessingPhase.DEFINITION, new DefineCodeBlock(symbolService)));
+            ParagraphsNode.class, ProcessingPhase.DEFINITION, new DefineCodeBlock(symbolAccumulatorService)));
     ctx.register(
         new ProcessorDescription(
             SectionNameNode.class,
             ProcessingPhase.DEFINITION,
-            new SectionNameRegister(symbolService)));
+            new SectionNameRegister(symbolAccumulatorService)));
     ctx.register(
         new ProcessorDescription(
             ParagraphNameNode.class,
             ProcessingPhase.DEFINITION,
-            new ParagraphNameRegister(symbolService)));
+            new ParagraphNameRegister(symbolAccumulatorService)));
     ctx.register(
         new ProcessorDescription(
             ProcedureDivisionBodyNode.class,
             ProcessingPhase.DEFINITION,
-            new DefineCodeBlock(symbolService)));
+            new DefineCodeBlock(symbolAccumulatorService)));
     // Phase USAGE
     ctx.register(
         new ProcessorDescription(
-            CodeBlockUsageNode.class, ProcessingPhase.USAGE, new CodeBlockUsage(symbolService)));
+            CodeBlockUsageNode.class, ProcessingPhase.USAGE, new CodeBlockUsage(symbolAccumulatorService)));
     ctx.register(
         new ProcessorDescription(
             RootNode.class, ProcessingPhase.USAGE, new RootNodeUpdateCopyNodesByPositionInTree()));
     ctx.register(
         new ProcessorDescription(
             QualifiedReferenceNode.class,
             ProcessingPhase.USAGE,
-            new QualifiedReferenceUpdateVariableUsage(symbolService)));
+            new QualifiedReferenceUpdateVariableUsage(symbolAccumulatorService)));
 
     // ENRICHMENT
     ctx.register(
         new ProcessorDescription(
             SectionNameNode.class,
             ProcessingPhase.VALIDATION,
-            new SectionNameNodeEnricher(symbolService)));
+            new SectionNameNodeEnricher(symbolAccumulatorService)));
     ctx.register(
         new ProcessorDescription(
             CodeBlockUsageNode.class,
             ProcessingPhase.VALIDATION,
-            new CodeBlockUsageNodeEnricher(symbolService)));
+            new CodeBlockUsageNodeEnricher(symbolAccumulatorService)));
 
     // Phase VALIDATION
     ctx.register(

server/engine/src/main/java/org/eclipse/lsp/cobol/core/engine/dialects/DialectService.java

@@ -31,7 +31,7 @@
 import org.eclipse.lsp.cobol.core.engine.dialects.daco.DaCoDialect;
 import org.eclipse.lsp.cobol.core.engine.dialects.daco.DaCoMaidProcessor;
 import org.eclipse.lsp.cobol.core.engine.dialects.idms.IdmsDialect;
-import org.eclipse.lsp.cobol.core.engine.symbols.SymbolService;
+import org.eclipse.lsp.cobol.core.engine.symbols.SymbolAccumulatorService;
 import org.eclipse.lsp.cobol.service.copybooks.CopybookService;
 
 import java.util.*;
@@ -47,7 +47,7 @@ public class DialectService {
   public DialectService(
       CopybookService copybookService,
       ParseTreeListener treeListener,
-      SymbolService symbolService,
+      SymbolAccumulatorService symbolAccumulatorService,
       MessageService messageService) {
     dialectSuppliers = new HashMap<>();
 
@@ -58,7 +58,7 @@ public DialectService(
         new DaCoDialect(
             messageService,
             new DaCoMaidProcessor(copybookService, treeListener, messageService),
-            symbolService);
+                symbolAccumulatorService);
     dialectSuppliers.put(dialect.getName(), dialect);
 
     dialectSuppliers.put(dialect.getName(), dialect);

server/engine/src/main/java/org/eclipse/lsp/cobol/core/engine/dialects/daco/DaCoCopyFromProcessor.java

@@ -24,7 +24,7 @@
 import org.eclipse.lsp.cobol.common.processor.ProcessingContext;
 import org.eclipse.lsp.cobol.common.processor.Processor;
 import org.eclipse.lsp.cobol.core.engine.dialects.daco.nodes.DaCoCopyFromNode;
-import org.eclipse.lsp.cobol.core.engine.symbols.SymbolService;
+import org.eclipse.lsp.cobol.core.engine.symbols.SymbolAccumulatorService;
 import org.eclipse.lsp.cobol.core.model.tree.variables.*;
 
 import java.util.List;
@@ -34,10 +34,10 @@
 
 /** Handle Copy From node */
 public class DaCoCopyFromProcessor implements Processor<DaCoCopyFromNode> {
-  private final SymbolService symbolService;
+  private final SymbolAccumulatorService symbolAccumulatorService;
 
-  public DaCoCopyFromProcessor(SymbolService symbolService) {
-    this.symbolService = symbolService;
+  public DaCoCopyFromProcessor(SymbolAccumulatorService symbolAccumulatorService) {
+    this.symbolAccumulatorService = symbolAccumulatorService;
   }
 
   @Override
@@ -68,7 +68,7 @@ private void astPostprocessing(DaCoCopyFromNode node, List<SyntaxError> errors)
       return;
     }
     copyFrom(node.getLevel(), protoCandidates.get(0), node.getParent(), node);
-    symbolService.registerVariablesInProgram(node.getParent());
+    symbolAccumulatorService.registerVariablesInProgram(node.getParent());
   }
 
   private void copyFrom(

server/engine/src/main/java/org/eclipse/lsp/cobol/core/engine/dialects/daco/DaCoDialect.java

@@ -37,7 +37,7 @@
 import org.eclipse.lsp.cobol.core.engine.dialects.daco.nodes.DaCoCopyFromNode;
 import org.eclipse.lsp.cobol.core.engine.dialects.daco.provider.DaCoImplicitCodeProvider;
 import org.eclipse.lsp.cobol.core.engine.dialects.idms.IdmsDialect;
-import org.eclipse.lsp.cobol.core.engine.symbols.SymbolService;
+import org.eclipse.lsp.cobol.core.engine.symbols.SymbolAccumulatorService;
 import org.eclipse.lsp.cobol.core.strategy.CobolErrorStrategy;
 import org.eclipse.lsp4j.Position;
 import org.eclipse.lsp4j.Range;
@@ -54,7 +54,7 @@ public final class DaCoDialect implements CobolDialect {
 
   private final MessageService messageService;
   private final DaCoMaidProcessor maidProcessor;
-  private final SymbolService symbolService;
+  private final SymbolAccumulatorService symbolAccumulatorService;
 
   /**
    * Gets the name of the dialect
@@ -136,6 +136,6 @@ public List<ProcessorDescription> getProcessors() {
     return Collections.singletonList(
         new ProcessorDescription(
             DaCoCopyFromNode.class, ProcessingPhase.POST_DEFINITION,
-                new DaCoCopyFromProcessor(symbolService)));
+                new DaCoCopyFromProcessor(symbolAccumulatorService)));
   }
 }

server/engine/src/main/java/org/eclipse/lsp/cobol/core/engine/symbols/SymbolService.java renamed to server/engine/src/main/java/org/eclipse/lsp/cobol/core/engine/symbols/SymbolAccumulatorService.java

@@ -18,43 +18,35 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Multimap;
 import com.google.inject.Singleton;
-import lombok.Value;
 import org.eclipse.lsp.cobol.common.error.ErrorSeverity;
 import org.eclipse.lsp.cobol.common.error.ErrorSource;
 import org.eclipse.lsp.cobol.common.error.SyntaxError;
 import org.eclipse.lsp.cobol.common.message.MessageTemplate;
-import org.eclipse.lsp.cobol.common.model.Context;
-import org.eclipse.lsp.cobol.common.model.tree.Node;
 import org.eclipse.lsp.cobol.common.model.NodeType;
+import org.eclipse.lsp.cobol.common.model.tree.Node;
 import org.eclipse.lsp.cobol.common.model.tree.ProgramNode;
-import org.eclipse.lsp.cobol.core.model.VariableUsageUtils;
-import org.eclipse.lsp.cobol.core.model.tree.*;
 import org.eclipse.lsp.cobol.common.model.tree.variable.VariableNode;
 import org.eclipse.lsp.cobol.common.model.tree.variable.VariableUsageNode;
-import org.eclipse.lsp.cobol.core.preprocessor.delegates.injector.ImplicitCodeUtils;
-import org.eclipse.lsp.cobol.service.CobolDocumentModel;
-import org.eclipse.lsp.cobol.service.delegates.validations.AnalysisResult;
+import org.eclipse.lsp.cobol.core.model.VariableUsageUtils;
+import org.eclipse.lsp.cobol.core.model.tree.*;
 import org.eclipse.lsp4j.Location;
-import org.eclipse.lsp4j.TextDocumentPositionParams;
 
 import java.util.*;
 import java.util.function.Function;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import static org.eclipse.lsp.cobol.common.model.tree.Node.hasType;
-import static org.eclipse.lsp.cobol.common.utils.RangeUtils.findNodeByPosition;
 
 /** Service to handle symbol information and dependencies */
 @Singleton
-public class SymbolService {
+public class SymbolAccumulatorService {
   private final Map<String, SymbolTable> programSymbols;
 
-  public SymbolService() {
+  public SymbolAccumulatorService() {
     this.programSymbols = Collections.synchronizedMap(new HashMap<>());
   }
 
-  public SymbolService(Map<String, SymbolTable> symbolTableMap) {
+  public SymbolAccumulatorService(Map<String, SymbolTable> symbolTableMap) {
     this.programSymbols = symbolTableMap;
   }
 
@@ -67,36 +59,6 @@ public SymbolService(Map<String, SymbolTable> symbolTableMap) {
   public void addVariableDefinition(ProgramNode programNode, VariableNode node) {
     createOrGetSymbolTable(programNode).getVariables().put(node.getName(), node);
   }
-  /**
-   * Find element using a position
-   *
-   * @param document the document to search in
-   * @param position the position to check
-   * @return element at specified position
-   */
-  public Optional<Context> findElementByPosition(
-      CobolDocumentModel document, TextDocumentPositionParams position) {
-    AnalysisResult result = document.getAnalysisResult();
-    if (result.getRootNode() == null) {
-      return Optional.empty();
-    }
-    Optional<Node> node = findNodeByPosition(result.getRootNode(), position.getTextDocument().getUri(), position.getPosition());
-    return node.filter(Context.class::isInstance)
-            .map(Context.class::cast)
-            .map(this::constructElementsExcludingImplicits);
-  }
-
-  private Context constructElementsExcludingImplicits(Context ctx) {
-    List<Location> definitions =
-        ctx.getDefinitions().stream().filter(uriNotImplicit()).collect(Collectors.toList());
-    List<Location> usages =
-        ctx.getUsages().stream().filter(uriNotImplicit()).collect(Collectors.toList());
-    return new Element("", definitions, usages);
-  }
-
-  private static Predicate<Location> uriNotImplicit() {
-    return i -> !ImplicitCodeUtils.isImplicit(i.getUri());
-  }
 
   /**
    * * Register variable definitions into nearest ProgramNode
@@ -287,25 +249,6 @@ public List<Location> getSectionLocations(
         .orElse(ImmutableList.of());
   }
 
-  /**
-   * Get paragraphs data
-   *
-   * @param programNode the program node
-   * @return map of paragraphs
-   */
-  public Map<String, CodeBlockReference> getParagraphMap(ProgramNode programNode) {
-    return createOrGetSymbolTable(programNode).getParagraphMap();
-  }
-  /**
-   * Get section data
-   *
-   * @param programNode the program node
-   * @return map of sections
-   */
-  public Map<String, CodeBlockReference> getSectionMap(ProgramNode programNode) {
-    return createOrGetSymbolTable(programNode).getSectionMap();
-  }
-
   /**
    * Extract all accumulated symbols information
    *
@@ -347,16 +290,6 @@ private Map<String, VariableNode> getMapOfGlobalVariables(ProgramNode programNod
     return result;
   }
 
-  /**
-   * Get variables data
-   *
-   * @param programNode the program node
-   * @return map of variables
-   */
-  public Multimap<String, VariableNode> getVariables(ProgramNode programNode) {
-    return createOrGetSymbolTable(programNode).getVariables();
-  }
-
   /**
    * Remove program related symbols
    *
@@ -369,11 +302,4 @@ public void reset(String documentUri) {
         .forEach(programSymbols::remove);
     programSymbols.remove(documentUri);
   }
-
-  @Value
-  private static class Element implements Context {
-    String name;
-    List<Location> definitions;
-    List<Location> usages;
-  }
 }