bundles/org.simantics.scl.ui/src/org/simantics/scl/ui/editor/completion/SCLTextEditorEnvironment.java

   1 package org.simantics.scl.ui.editor.completion;
   2
   3 import java.io.StringReader;
   4 import java.util.ArrayList;
   5 import java.util.Collections;
   6 import java.util.Comparator;
   7 import java.util.List;
   8
   9 import org.eclipse.jface.text.IDocument;
  10 import org.eclipse.jface.text.contentassist.ICompletionProposal;
  11 import org.simantics.scl.compiler.common.names.Name;
  12 import org.simantics.scl.compiler.compilation.EnvironmentOfModule;
  13 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
  14 import org.simantics.scl.compiler.environment.AmbiguousNameException;
  15 import org.simantics.scl.compiler.environment.Environment;
  16 import org.simantics.scl.compiler.environment.Environments;
  17 import org.simantics.scl.compiler.errors.Failable;
  18 import org.simantics.scl.compiler.internal.parsing.exceptions.SCLSyntaxErrorException;
  19 import org.simantics.scl.compiler.internal.parsing.parser.SCLParserImpl;
  20 import org.simantics.scl.compiler.module.ImportDeclaration;
  21 import org.simantics.scl.compiler.module.InvalidModulePathException;
  22 import org.simantics.scl.compiler.module.Module;
  23 import org.simantics.scl.compiler.module.ModuleUtils;
  24 import org.simantics.scl.compiler.module.repository.ImportFailureException;
  25 import org.simantics.scl.compiler.types.TCon;
  26 import org.simantics.scl.osgi.SCLOsgi;
  27
  28 public class SCLTextEditorEnvironment {
  29
  30     private String moduleName;
  31     private SCLCompletionProposal[] proposalCache = new SCLCompletionProposal[0];
  32     private List<SCLCompletionProposal> moduleProposalCache = new ArrayList<>(0);
  33     private Environment env;
  34
  35     private List<ImportDeclaration> cachedImports = new ArrayList<>();
  36     private boolean cacheUpdated = false;
  37
  38     public SCLTextEditorEnvironment(String moduleName) {
  39         this.moduleName = moduleName;
  40     }
  41
  42     public void updateModuleName(String moduleName) {
  43         this.moduleName = moduleName;
  44     }
  45
  46     public void updateEnvironment(IDocument document) {
  47         String contents = document.get();
  48         // Strip triple quoted strings from the contents since they may contain lines that look exactly like normal imports / includes
  49         contents = contents.replaceAll("(?s)\"\"\".*?\"\"\"", "\"\"");
  50         // Strip multiline comments since they may contain lines that look exactly like normal imports / includes
  51         contents = contents.replaceAll("(?s)/\\*.*?\\*/", "");
  52
  53         String[] lines = contents.split("\\R+"); //$NON-NLS-1$
  54         List<ImportDeclaration> imports = new ArrayList<>();
  55         imports.add(new ImportDeclaration("StandardLibrary", "")); //$NON-NLS-1$ //$NON-NLS-2$
  56         for (String line : lines) {
  57             line = line.trim();
  58             if (line.startsWith("import ") || line.startsWith("include ")) { //$NON-NLS-1$ //$NON-NLS-2$
  59                 SCLParserImpl parser = new SCLParserImpl(new StringReader(line));
  60                 try {
  61                     ImportDeclaration importDecl = (ImportDeclaration)parser.parseImport();
  62                     imports.add(importDecl);
  63                 } catch (SCLSyntaxErrorException e) {
  64                     // Import cannot be handled, ignore
  65                 }
  66             }
  67         }
  68
  69         imports = processRelativeImports(imports);
  70         if (!imports.equals(cachedImports)) {
  71             cachedImports = imports;
  72             try {
  73                 env = SCLOsgi.MODULE_REPOSITORY.createEnvironment(cachedImports.toArray(new ImportDeclaration[cachedImports.size()]), null);
  74                 Failable<Module> module = SCLOsgi.MODULE_REPOSITORY.getModule(moduleName);
  75                 if(module.didSucceed())
  76                     env = new EnvironmentOfModule(env, module.getResult());
  77             } catch (ImportFailureException e) {
  78                 //e.printStackTrace();
  79             }
  80         }
  81     }
  82
  83     public ICompletionProposal[] getCompletionProposals(String prefix, int offset) {
  84         int p = prefix.lastIndexOf('.');
  85         String lastPart = p==-1 ? prefix : prefix.substring(p+1);
  86
  87         List<SCLCompletionProposal> proposals = new ArrayList<>();
  88         for(SCLValue value : Environments.findValuesForPrefix(env, prefix)) {
  89             Name name = value.getName();
  90             if((name.module.equals(moduleName) || !value.isPrivate()) && !(name.name.contains("$") && Character.isLetter(name.name.charAt(0)))) //$NON-NLS-1$
  91                 proposals.add(new SCLCompletionProposal(value, offset - lastPart.length(), lastPart));
  92         }
  93         for(TCon type : Environments.findTypesForPrefix(env, prefix)) {
  94             proposals.add(new SCLCompletionProposal(type.name, type.module, SCLCompletionType.TYPE, offset - lastPart.length(), lastPart));
  95         }
  96
  97         if(!prefix.contains(".")) { //$NON-NLS-1$
  98             for (ImportDeclaration decl : cachedImports) {
  99                 if (decl.localName != null && !decl.localName.isEmpty() && decl.localName.toLowerCase().startsWith(prefix.toLowerCase())) {
 100                     proposals.add(new SCLCompletionProposal(decl.localName, decl.moduleName, SCLCompletionType.CONST, offset - prefix.length(), prefix));
 101                 }
 102             }
 103         }
 104         Collections.sort(proposals, COMPARATOR);
 105         moduleProposalCache = proposals;
 106         proposalCache = moduleProposalCache.toArray(new SCLCompletionProposal[moduleProposalCache.size()]);
 107         return proposalCache;
 108     }
 109
 110     private ArrayList<ImportDeclaration> processRelativeImports(List<ImportDeclaration> relativeImports) {
 111         ArrayList<ImportDeclaration> absoluteImports = new ArrayList<ImportDeclaration>(relativeImports.size());
 112         for(ImportDeclaration relativeImport : relativeImports) {
 113                         try {
 114                                 String absoluteModuleName = ModuleUtils.resolveAbsolutePath(moduleName, relativeImport.moduleName);
 115                 absoluteImports.add(new ImportDeclaration(
 116                         relativeImport.location,
 117                         absoluteModuleName, relativeImport.localName,
 118                         relativeImport.reexport, relativeImport.spec));
 119                         } catch (InvalidModulePathException e) {
 120                 // Nothing to do
 121                         }
 122         }
 123         return absoluteImports;
 124     }
 125
 126     private static final Comparator<SCLCompletionProposal> COMPARATOR = new Comparator<SCLCompletionProposal>() {
 127
 128         @Override
 129         public int compare(SCLCompletionProposal prop1, SCLCompletionProposal prop2) {
 130             if (prop1.isPrivate() && !prop2.isPrivate())
 131                 return -1;
 132             else if (!prop1.isPrivate() && prop2.isPrivate())
 133                 return 1;
 134             return prop1.getName().compareTo(prop2.getName());
 135         }
 136     };
 137
 138     public SCLValue getValue(String text) {
 139         try {
 140             return Environments.getValue(env, text);
 141         } catch (AmbiguousNameException e) {
 142             // TODO could also return one of the conflicting alternatives
 143             return null;
 144         }
 145     }
 146
 147     public String getHoverInfo(String text) {
 148         SCLValue value = getValue(text);
 149         if (value != null)
 150             return value.getDocumentation();
 151         else
 152             return null;
 153     }
 154 }