X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.scl.compiler%2Fsrc%2Forg%2Fsimantics%2Fscl%2Fcompiler%2Fmodule%2Frepository%2FModuleRepository.java;h=0f0b8542049a53c7f8eea2667ba15c40789f0f7b;hp=40c69f4348861e2d4bd58877d762f4677d90c7f1;hb=7444d4b3a2f3c25fac462d8a168898656dafd52e;hpb=90b5d2ee1cfe82a75a097116f2f34ddb1cdff067

diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/module/repository/ModuleRepository.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/module/repository/ModuleRepository.java
index 40c69f434..0f0b85420 100644
--- a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/module/repository/ModuleRepository.java
+++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/module/repository/ModuleRepository.java
@@ -7,8 +7,10 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
+import org.simantics.scl.compiler.compilation.CompilationContext;
 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
 import org.simantics.scl.compiler.environment.ConcreteEnvironment;
+import org.simantics.scl.compiler.environment.EmptyEnvironment;
 import org.simantics.scl.compiler.environment.Environment;
 import org.simantics.scl.compiler.environment.NamespaceImpl.ModuleImport;
 import org.simantics.scl.compiler.environment.NamespaceSpec;
@@ -19,6 +21,7 @@ import org.simantics.scl.compiler.errors.CompilationError;
 import org.simantics.scl.compiler.errors.DoesNotExist;
 import org.simantics.scl.compiler.errors.Failable;
 import org.simantics.scl.compiler.errors.Failure;
+import org.simantics.scl.compiler.errors.Locations;
 import org.simantics.scl.compiler.errors.Success;
 import org.simantics.scl.compiler.module.ImportDeclaration;
 import org.simantics.scl.compiler.module.Module;
@@ -36,6 +39,7 @@ import org.simantics.scl.compiler.top.ValueNotFound;
 import org.simantics.scl.compiler.types.Types;
 
 import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TObjectLongHashMap;
 import gnu.trove.procedure.TObjectObjectProcedure;
 import gnu.trove.set.hash.THashSet;
 
@@ -159,7 +163,7 @@ public class ModuleRepository {
                         Collection<ImportDeclaration> dependencies = module.getDependencies();
                         THashMap<String, ModuleEntry> moduleEntries;
                         try {
-                            moduleEntries = getModuleEntries(dependencies.toArray(new ImportDeclaration[dependencies.size()]), null);
+                            moduleEntries = getModuleEntries(null, dependencies.toArray(new ImportDeclaration[dependencies.size()]), null, false);
                         } catch (ImportFailureException e) {
                             throw new InternalCompilerError(e);
                         }
@@ -254,25 +258,35 @@ public class ModuleRepository {
     }
     
     private THashMap<String, ModuleEntry> getModuleEntries(
+            CompilationContext compilationContext,
             ImportDeclaration[] imports,
-            UpdateListener listener) throws ImportFailureException {
+            UpdateListener listener,
+            boolean robustly) throws ImportFailureException {
         THashMap<String, ModuleEntry> result = new THashMap<String, ModuleEntry>();
         Collection<ImportFailure> failures = null;
         
-        THashSet<String> originalImports = new THashSet<String>(); 
+        TObjectLongHashMap<String> originalImports = new TObjectLongHashMap<String>(); 
         ArrayList<ImportDeclaration> stack = new ArrayList<ImportDeclaration>(imports.length);
         for(ImportDeclaration import_ : imports) {
             stack.add(import_);
-            originalImports.add(import_.moduleName);
+            originalImports.put(import_.moduleName, import_.location);
         }
         while(!stack.isEmpty()) {
             ImportDeclaration import_ = stack.remove(stack.size()-1);
             if(!result.containsKey(import_.moduleName)) {
-                ModuleEntry entry = getModuleEntry(import_.moduleName, originalImports.contains(import_.moduleName) ? listener : null);
+                boolean originalImport = originalImports.contains(import_.moduleName);
+                ModuleEntry entry = getModuleEntry(import_.moduleName, originalImport ? listener : null);
                 Failable<Module> compilationResult = entry.compilationResult;
                 if(compilationResult.didSucceed()) {
                     result.put(import_.moduleName, entry);
                     stack.addAll(compilationResult.getResult().getDependencies());
+                    if(originalImport) {
+                        String deprecation = compilationResult.getResult().getDeprecation();
+                        if(deprecation != null && compilationContext != null) {
+                            long location = originalImport ? originalImports.get(import_.moduleName) : Locations.NO_LOCATION;
+                            compilationContext.errorLog.logWarning(location, "Deprecated module " + import_.moduleName   + (deprecation.isEmpty() ? "." : ": " + deprecation));
+                        }
+                    }
                 }
                 else {
                     if(failures == null)
@@ -285,7 +299,7 @@ public class ModuleRepository {
             }
         }
         
-        if(failures != null)
+        if(failures != null && !robustly)
             throw new ImportFailureException(failures);
         
         return result;
@@ -318,11 +332,32 @@ public class ModuleRepository {
     public Environment createEnvironment(
             ImportDeclaration[] imports,
             UpdateListener listener) throws ImportFailureException {
-        THashMap<String, ModuleEntry> entries = getModuleEntries(imports, listener);
+        return createEnvironment(null, imports, listener);
+    }
+    
+    public Environment createEnvironment(
+            CompilationContext compilationContext,
+            ImportDeclaration[] imports,
+            UpdateListener listener) throws ImportFailureException {
+        THashMap<String, ModuleEntry> entries = getModuleEntries(compilationContext, imports, listener, false);
         THashMap<String, Module> moduleMap = mapEntriesToModules(entries);
         return createEnvironment(moduleMap, imports);
     }
     
+    public Environment createEnvironmentRobustly(
+            CompilationContext compilationContext,
+            ImportDeclaration[] imports,
+            UpdateListener listener) {
+        try {
+            THashMap<String, ModuleEntry> entries = getModuleEntries(compilationContext, imports, listener, true);
+            THashMap<String, Module> moduleMap = mapEntriesToModules(entries);
+            return createEnvironment(moduleMap, imports);
+        } catch(ImportFailureException e) {
+            // Should not happen because of robust flag
+            return EmptyEnvironment.INSTANCE;
+        }
+    }
+    
     public Environment createEnvironment(
             EnvironmentSpecification specification,
             UpdateListener listener) throws ImportFailureException {
@@ -334,6 +369,10 @@ public class ModuleRepository {
         return createRuntimeEnvironment(environmentSpecification, parentClassLoader, null);
     }
     
+    public RuntimeEnvironment createRuntimeEnvironment(EnvironmentSpecification environmentSpecification) throws ImportFailureException {
+        return createRuntimeEnvironment(environmentSpecification, getClass().getClassLoader());
+    }
+    
     public RuntimeEnvironment createRuntimeEnvironment(
             EnvironmentSpecification environmentSpecification,
             ClassLoader parentClassLoader,
@@ -348,14 +387,15 @@ public class ModuleRepository {
             ImportDeclaration[] imports,
             ClassLoader parentClassLoader,
             UpdateListener listener) throws ImportFailureException {
-        THashMap<String, ModuleEntry> entries = getModuleEntries(imports, listener);
+        THashMap<String, ModuleEntry> entries = getModuleEntries(null, imports, listener, false);
         THashMap<String, Module> moduleMap = mapEntriesToModules(entries);
         Environment environment = createEnvironment(moduleMap, imports);
         THashMap<String, RuntimeModule> runtimeModuleMap = mapEntriesToRuntimeModules(entries);
         return new RuntimeEnvironmentImpl(environment, parentClassLoader, runtimeModuleMap);
     }
     
-    private static Environment createEnvironment(THashMap<String, Module> moduleMap, 
+    private static Environment createEnvironment(
+            THashMap<String, Module> moduleMap, 
             ImportDeclaration[] imports) {
         NamespaceSpec spec = new NamespaceSpec();
         for(ImportDeclaration import_ : imports)