import org.simantics.scl.compiler.internal.elaboration.profiling.BranchPointInjector;
import org.simantics.scl.compiler.internal.elaboration.utils.StronglyConnectedComponents;
import org.simantics.scl.compiler.internal.header.ModuleHeader;
+import org.simantics.scl.compiler.internal.parsing.Token;
import org.simantics.scl.compiler.internal.parsing.declarations.ConstructorAst;
import org.simantics.scl.compiler.internal.parsing.declarations.DAnnotationAst;
import org.simantics.scl.compiler.internal.parsing.declarations.DClassAst;
import org.simantics.scl.compiler.internal.parsing.declarations.DValueAst;
import org.simantics.scl.compiler.internal.parsing.declarations.DValueTypeAst;
import org.simantics.scl.compiler.internal.parsing.exceptions.SCLSyntaxErrorException;
+import org.simantics.scl.compiler.internal.parsing.parser.SCLTerminals;
import org.simantics.scl.compiler.internal.parsing.translation.ProcessedDClassAst;
import org.simantics.scl.compiler.internal.parsing.translation.ProcessedDInstanceAst;
import org.simantics.scl.compiler.internal.parsing.translation.RelationRepository;
import org.simantics.scl.compiler.module.ImportDeclaration;
import org.simantics.scl.compiler.module.InvalidModulePathException;
import org.simantics.scl.compiler.module.ModuleUtils;
+import org.simantics.scl.compiler.module.debug.ModuleDebugInfo;
import org.simantics.scl.compiler.module.repository.ImportFailure;
import org.simantics.scl.compiler.module.repository.ImportFailureException;
+import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.TForAll;
import org.simantics.scl.compiler.types.TFun;
this.errorLog = compilationContext.errorLog;
this.moduleName = moduleName;
this.moduleHeader = moduleHeader;
- importsAst = processRelativeImports(importsAst);
+ if(moduleName != null)
+ importsAst = processRelativeImports(compilationContext.errorLog, moduleName, importsAst);
this.importsAst = importsAst;
this.jrvFactory = jrvFactory;
this.javaReferenceValidator = moduleHeader == null || moduleHeader.classLoader == null
module = new ConcreteModule(moduleName);
compilationContext.module = module;
+ compilationContext.moduleRepository = localEnvironmentFactory.getModuleRepository();
if(moduleHeader != null) {
if(moduleHeader.defaultLocalName != null)
module.setDefaultLocalName(moduleHeader.defaultLocalName);
compilationContext.namingPolicy = new JavaNamingPolicy(moduleName);
}
- private ArrayList<ImportDeclaration> processRelativeImports(ArrayList<ImportDeclaration> relativeImports) {
+ public static ArrayList<ImportDeclaration> processRelativeImports(ErrorLog errorLog, String moduleName, ArrayList<ImportDeclaration> relativeImports) {
ArrayList<ImportDeclaration> absoluteImports = new ArrayList<ImportDeclaration>(relativeImports.size());
for(ImportDeclaration relativeImport : relativeImports) {
if(relativeImport.moduleName.startsWith(".")) {
relativeImport.reexport, relativeImport.spec);
absoluteImports.add(absoluteImport);
} catch (InvalidModulePathException e) {
- errorLog.log(relativeImport.location, e.getMessage());
+ if(errorLog != null)
+ errorLog.log(relativeImport.location, e.getMessage());
}
}
else
method.setDefaultImplementation(Name.create(moduleName, fullName));
valueDefinitionsAst.addDefinitions(fullName, defs);
- /*valueDefinitionsAst.addAnnotation(fullName, new DAnnotationAst(new EVar("@private"),
- Collections.<Expression>emptyList()));*/
- supplementedTypeAnnotations.add(new SupplementedValueType(defs.get(0).location, fullName, method.getType()));
+ supplementedTypeAnnotations.add(new SupplementedValueType(defs.get(0).location, fullName, method.getType()));
+ valueDefinitionsAst.setDerived(fullName);
}
module.addTypeClass(classAst.name, typeClass);
final THashMap<SectionName, Query[]> sections = new THashMap<SectionName, Query[]>();
- final TranslationContext context = createTranslationContext();
+ final TranslationContext context = createTranslationContext(ruleName);
if(length > 0) {
THashMap<String, Variable> variables = context.getVariables();
for(TransformationRule extendsRule : extendsRules) {
continue;
try {
SCLValue value = module.getValue(name);
- TranslationContext context = createTranslationContext();
+ TranslationContext context = createTranslationContext(name);
Expression expression = context.translateCases2(defs);
value.setExpression(expression);
continue;
try {
SCLValue value = module.getValue(name);
- TranslationContext context = createTranslationContext();
+ TranslationContext context = createTranslationContext(name);
Expression expression = context.translateCases2(defs);
value.setExpression(expression);
DRelationAst definition = definitions.get(0);
ConcreteRelation relation = (ConcreteRelation)module.getRelation(name);
relation.location = definition.location;
- TranslationContext context = createTranslationContext();
+ TranslationContext context = createTranslationContext(name);
definition.translateTo(context, relation);
}
}
- private TranslationContext createTranslationContext() {
- return new TranslationContext(compilationContext, null);
+ private TranslationContext createTranslationContext(String definitionName) {
+ return new TranslationContext(compilationContext, null, definitionName);
}
private void handleAnnotation(SCLValue value, ArrayList<DValueAst> defs, DAnnotationAst annotation) {
branchPoints.put(valueName, injector.getAndClearBranchPoints());
}
}
+
+ public void collectDebugInfo() {
+ module.moduleDebugInfo = compilationContext.moduleDebugInfo = new ModuleDebugInfo();
+ }
}