import org.simantics.scl.compiler.constants.JavaTypeInstanceConstructor;
import org.simantics.scl.compiler.constants.SCLConstructor;
import org.simantics.scl.compiler.constants.StringConstant;
+import org.simantics.scl.compiler.constants.componentaccess.ComponentAccess;
+import org.simantics.scl.compiler.constants.componentaccess.FieldComponentAccess;
import org.simantics.scl.compiler.constants.generic.CallJava;
import org.simantics.scl.compiler.constants.generic.ClassRef;
import org.simantics.scl.compiler.constants.generic.ConvertToListFilter;
import org.simantics.scl.compiler.constants.generic.MethodRef;
-import org.simantics.scl.compiler.constants.generic.MethodRef.FieldRef;
import org.simantics.scl.compiler.constants.generic.OutputFilter;
import org.simantics.scl.compiler.constants.generic.ParameterStackItem;
import org.simantics.scl.compiler.constants.generic.Pop2OutputFilter;
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.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;
ArrayList<StandardTypeConstructor> dataTypes = new ArrayList<StandardTypeConstructor>();
THashMap<String, ClassRef> classRefs = new THashMap<String, ClassRef>();
THashMap<String, BranchPoint[]> branchPoints;
+
+ THashMap<String, EVar> exportMap = null;
public Elaboration(CompilationContext compilationContext, CompilationTimer timer, EnvironmentFactory localEnvironmentFactory,
String moduleName, ModuleHeader moduleHeader, ArrayList<ImportDeclaration> importsAst,
compilationContext.environment = new EnvironmentOfModule(importedEnvironment, module);
} catch (ImportFailureException e) {
for(ImportFailure failure : e.failures)
- errorLog.log(new CompilationError(failure.location, failure.toString(), ErrorSeverity.IMPORT_ERROR));
+ errorLog.log(new CompilationError(failure.location, failure.toString(),
+ failure.reason == ImportFailure.MODULE_DOES_NOT_EXIST_REASON ? ErrorSeverity.ERROR : ErrorSeverity.IMPORT_ERROR));
return;
}
for(ImportDeclaration importAst : importsAst)
parameterTypes[i] = context.toType(constructor.parameters[i]);
String javaName = constructors.length == 1 ? className
: compilationContext.namingPolicy.getConstructorClassName(name);
- String[] fieldNames = null;
+ ComponentAccess[] componentAccesses = null;
for(DAnnotationAst annotation : constructor.annotations)
if(annotation.id.text.equals("@JavaType")) {
try {
else if(annotation.id.text.equals("@FieldNames")) {
try {
EListLiteral literal = (EListLiteral)annotation.parameters[0];
- fieldNames = new String[literal.getComponents().length];
- for(int i=0;i<fieldNames.length;++i) {
+ componentAccesses = new ComponentAccess[literal.getComponents().length];
+ for(int i=0;i<componentAccesses.length;++i) {
Expression component = literal.getComponents()[i];
if(component instanceof EVar)
- fieldNames[i] = ((EVar)component).name;
+ componentAccesses[i] = new FieldComponentAccess(((EVar)component).name);
else if(component instanceof ELiteral)
- fieldNames[i] = ((StringConstant)((ELiteral)component).getValue()).getValue();
+ componentAccesses[i] = new FieldComponentAccess(((StringConstant)((ELiteral)component).getValue()).getValue());
}
} catch(Exception e) {
errorLog.log(annotation.parameters[0].location, "Invalid annotation parameter.");
- fieldNames = null;
+ componentAccesses = null;
}
}
constructors[j] = new Constructor(constructor.location, dataType,
Name.create(moduleName, name),
parameterTypes, javaName);
- constructors[j].fieldNames = fieldNames;
+ constructors[j].componentAccesses = componentAccesses;
constructors[j].recordFieldNames = constructor.fieldNames;
}
if(constructors.length == 1) {
@Override
public void run() {
Type in = Types.apply(dataType.name, dataType.parameters);
+
+ ComponentAccess[] componentAccesses = constructor.componentAccesses != null
+ ? constructor.componentAccesses
+ : SCLConstructor.DEFAULT_FIELD_NAMES[constructor.recordFieldNames.length];
for(int i=0;i<constructor.recordFieldNames.length;++i) {
Type out = constructor.parameterTypes[i];
Constant accessor;
if(trivialDataType)
accessor = new SafeCoerce(dataType.parameters, in, out);
- else
+ else
accessor = new CallJava(dataType.parameters, Types.NO_EFFECTS, out,
new Type[] {in}, new StackItem[] {new ParameterStackItem(0, in)},
- new FieldRef(constructor.javaName, constructor.fieldNames != null ? constructor.fieldNames[i] : "c" + i,
- javaTypeTranslator.toTypeDesc(out)),
+ componentAccesses[i].toMethodRef(constructor.javaName, javaTypeTranslator.toTypeDesc(out)),
null);
module.addFieldAccessor(constructor.recordFieldNames[i], accessor);
}
isPrivate = true;
}
}
+ if(exportMap != null)
+ isPrivate = exportMap.remove(name) == null;
Type type = createTypeTranslationContext().toType(javaMethod.type);
int constructorTag = 0;
for(Constructor constructor : dataType.constructors) {
SCLValue value = new SCLValue(constructor.name);
+ value.parameterNames = constructor.recordFieldNames;
value.definitionLocation = constructor.loc;
SCLConstructor sclConstructor =
new SCLConstructor(
constructor.getTypeVariables(),
constructorTag++,
constructor.getReturnType(),
- constructor.fieldNames == null
+ constructor.componentAccesses == null
? SCLConstructor.DEFAULT_FIELD_NAMES[constructor.getParameterTypes().length]
- : constructor.fieldNames,
- constructor.recordFieldNames,
+ : constructor.componentAccesses,
constructor.getParameterTypes());
if(dataType.constructors.length == 1 && (
dataType.getTypeDesc() == null ||
typeMap.put(name.name, valueTypeAst);
}
- THashMap<String, EVar> exportMap = null;
- if(moduleHeader != null && moduleHeader.export != null) {
- exportMap = new THashMap<String, EVar>();
- for(EVar export : moduleHeader.export)
- if(exportMap.put(export.name, export) != null)
- errorLog.log(export.location, "The symbol " + export.name + " is exported multiple times.");
- }
-
for(String name : valueDefinitionsAst.getValueNames()) {
ArrayList<DValueAst> defs = valueDefinitionsAst.getDefinition(name);
if(defs.size() != 1 || !(defs.get(0).value instanceof EPreCHRRulesetConstructor))
throw e;
}
}
- if(exportMap != null)
- for(EVar export : exportMap.values())
- errorLog.log(export.location, "The symbol " + export.name + " is not defined in the module.");
for(String name : relationDefinitionsAst.getRelationNames()) {
ArrayList<DRelationAst> definitions = relationDefinitionsAst.getDefinition(name);
if(definitions.size() > 1) {
public void collectDebugInfo() {
module.moduleDebugInfo = compilationContext.moduleDebugInfo = new ModuleDebugInfo();
}
+
+ public void prepareExports() {
+ if(moduleHeader != null && moduleHeader.export != null) {
+ exportMap = new THashMap<String, EVar>();
+ for(EVar export : moduleHeader.export)
+ if(exportMap.put(export.name, export) != null)
+ errorLog.log(export.location, "The symbol " + export.name + " is exported multiple times.");
+ }
+ }
+
+ public void checkExports() {
+ if(exportMap != null)
+ for(EVar export : exportMap.values())
+ errorLog.log(export.location, "The symbol " + export.name + " is not defined in the module.");
+ }
}