Merge pull request #163 from ZenCodeLang/feature/refactor-kindlichs-t…

…ests-for-crafttweaker-hacks

Feature/refactor kindlichs tests for crafttweaker (hacks to get stuff running)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/ModuleSpace.java

@@ -6,9 +6,9 @@
 import org.openzen.zenscript.codemodel.annotations.NativeAnnotationDefinition;
 import org.openzen.zenscript.codemodel.annotations.PreconditionAnnotationDefinition;
 import org.openzen.zenscript.codemodel.compilation.CompileErrors;
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.globals.IGlobal;
+import org.openzen.zenscript.codemodel.identifiers.ExpansionSymbol;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -19,7 +19,7 @@ public final class ModuleSpace {
 	public final ZSPackage rootPackage = new ZSPackage(null, "");
 	public final ZSPackage stdlib = new ZSPackage(rootPackage, "stdlib");
 
-	private final List<ExpansionDefinition> expansions = new ArrayList<>();
+	private final List<ExpansionSymbol> expansions = new ArrayList<>();
 	private final Map<String, IGlobal> globals = new HashMap<>();
 	private final List<AnnotationDefinition> annotations;
 	private final Map<String, SemanticModule> modules = new HashMap<>();
@@ -43,6 +43,10 @@ public void addModule(String name, SemanticModule dependency) throws CompileExce
 		}
 	}
 
+	public void addExpansion(ExpansionSymbol expansion) {
+		expansions.add(expansion);
+	}
+
 	public void addGlobal(String name, IGlobal global) {
 		globals.put(name, global);
 	}
@@ -55,7 +59,7 @@ public ZSPackage collectPackages() {
 		return rootPackage;
 	}
 
-	public List<ExpansionDefinition> collectExpansions() {
+	public List<ExpansionSymbol> collectExpansions() {
 		return expansions;
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/PackageDefinitions.java

@@ -1,7 +1,7 @@
 package org.openzen.zenscript.codemodel;
 
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.identifiers.ExpansionSymbol;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -35,10 +35,10 @@ public void registerTo(ZSPackage pkg) {
 		}
 	}
 
-	public void registerExpansionsTo(List<ExpansionDefinition> expansions) {
+	public void registerExpansionsTo(List<ExpansionSymbol> expansions) {
 		for (HighLevelDefinition definition : definitions) {
-			if (definition instanceof ExpansionDefinition)
-				expansions.add((ExpansionDefinition) definition);
+			if (definition instanceof ExpansionSymbol)
+				expansions.add((ExpansionSymbol) definition);
 		}
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/SemanticModule.java

@@ -8,6 +8,7 @@
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.globals.IGlobal;
+import org.openzen.zenscript.codemodel.identifiers.ExpansionSymbol;
 import org.openzen.zenscript.codemodel.identifiers.ModuleSymbol;
 
 import java.util.*;
@@ -28,7 +29,7 @@ public class SemanticModule {
 	public final PackageDefinitions definitions;
 	public final List<ScriptBlock> scripts;
 	public final Map<String, IGlobal> globals = new HashMap<>();
-	public final List<ExpansionDefinition> expansions;
+	public final List<ExpansionSymbol> expansions;
 	public final AnnotationDefinition[] annotations;
 	public final IZSLogger logger;
 
@@ -41,7 +42,7 @@ public SemanticModule(
 			ZSPackage modulePackage,
 			PackageDefinitions definitions,
 			List<ScriptBlock> scripts,
-			List<ExpansionDefinition> expansions,
+			List<ExpansionSymbol> expansions,
 			AnnotationDefinition[] annotations,
 			IZSLogger logger) {
 		this.name = module.name;
@@ -68,15 +69,15 @@ public SemanticModule normalize() {
 		if (state != State.ASSEMBLED)
 			throw new IllegalStateException("Module is invalid");
 
-		AnnotationProcessor annotationProcessor = new AnnotationProcessor(expansions);
+		AnnotationProcessor annotationProcessor = new AnnotationProcessor(Collections.unmodifiableList(expansions));
 		List<ScriptBlock> processedScripts = new ArrayList<>();
 
 		for (ScriptBlock block : scripts)
 			processedScripts.add(annotationProcessor.process(block));
 
 		Stream.concat(
 				definitions.getAll().stream(),
-				expansions.stream()
+				expansions.stream().filter(e -> e instanceof ExpansionDefinition).map(e -> (ExpansionDefinition) e)
 		).forEach(annotationProcessor::process);
 
 		return new SemanticModule(
@@ -98,7 +99,7 @@ public ModuleContext getContext() {
 	}
 
 	public CompileContext createCompileContext() {
-		return new CompileContext(rootPackage, modulePackage, expansions, globals, Arrays.asList(annotations));
+		return new CompileContext(rootPackage, modulePackage, Collections.unmodifiableList(expansions), globals, Arrays.asList(annotations));
 	}
 
 	public enum State {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationProcessor.java

@@ -4,6 +4,7 @@
 import org.openzen.zenscript.codemodel.ModuleProcessor;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.identifiers.ExpansionSymbol;
 import org.openzen.zenscript.codemodel.identifiers.instances.MethodInstance;
 import org.openzen.zenscript.codemodel.member.*;
 import org.openzen.zenscript.codemodel.statement.Statement;
@@ -12,9 +13,9 @@
 import java.util.List;
 
 public class AnnotationProcessor implements ModuleProcessor {
-	private final List<ExpansionDefinition> expansions;
+	private final List<ExpansionSymbol> expansions;
 
-	public AnnotationProcessor(List<ExpansionDefinition> expansions) {
+	public AnnotationProcessor(List<ExpansionSymbol> expansions) {
 		this.expansions = expansions;
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CompileContext.java

@@ -11,6 +11,7 @@
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.identifiers.ExpansionSymbol;
 import org.openzen.zenscript.codemodel.identifiers.TypeSymbol;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
@@ -26,15 +27,15 @@
 public class CompileContext extends AbstractTypeBuilder implements TypeResolver {
 	private final ZSPackage rootPackage;
 	private final ZSPackage modulePackage;
-	private final List<ExpansionDefinition> expansions;
+	private final List<ExpansionSymbol> expansions;
 	private final Map<String, IGlobal> globals;
 	private final Map<String, CompilingDefinition> compiling = new HashMap<>();
 	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
 
 	public CompileContext(
 			ZSPackage rootPackage,
 			ZSPackage modulePackage,
-			List<ExpansionDefinition> expansions,
+			List<ExpansionSymbol> expansions,
 			Map<String, IGlobal> globals,
 			List<AnnotationDefinition> annotations
 	) {
@@ -86,21 +87,8 @@ public Optional<IGlobal> findGlobal(String name) {
 	public ResolvedType resolve(TypeID type) {
 		ResolvedType base = type.resolve();
 		List<ResolvedType> resolutions = new ArrayList<>();
-		for (ExpansionDefinition expansion : expansions) {
-			if (expansion.target == null)
-				throw new RuntimeException(expansion.position.toString() + ": Missing expansion target");
-
-			Map<TypeParameter, TypeID> mapping = TypeMatcher.match(type, expansion.target);
-			if (mapping == null)
-				continue;
-
-			TypeID[] expansionTypeArguments = Stream.of(expansion.typeParameters).map(mapping::get).toArray(TypeID[]::new);
-			MemberSet.Builder resolution = MemberSet.create();
-			GenericMapper mapper = new GenericMapper(mapping, expansionTypeArguments);
-			for (IDefinitionMember member : expansion.members)
-				member.registerTo(type, resolution, mapper);
-
-			resolutions.add(resolution.build());
+		for (ExpansionSymbol expansion : expansions) {
+			expansion.resolve(type).ifPresent(resolutions::add);
 		}
 		return ExpandedResolvedType.of(base, resolutions);
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/ModuleContext.java

@@ -1,5 +1,6 @@
 package org.openzen.zenscript.codemodel.context;
 
+import org.openzen.zenscript.codemodel.identifiers.ExpansionSymbol;
 import org.openzen.zenscript.codemodel.identifiers.ModuleSymbol;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
@@ -8,12 +9,12 @@
 
 public class ModuleContext {
 	public final ModuleSymbol module;
-	public final List<ExpansionDefinition> expansions;
+	public final List<ExpansionSymbol> expansions;
 	public final ZSPackage root;
 
 	public ModuleContext(
 			ModuleSymbol module,
-			List<ExpansionDefinition> expansions,
+			List<ExpansionSymbol> expansions,
 			ZSPackage root) {
 		this.module = module;
 		this.expansions = expansions;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/ExpansionDefinition.java

@@ -1,12 +1,23 @@
 package org.openzen.zenscript.codemodel.definition;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.compilation.ResolvedType;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.identifiers.ExpansionSymbol;
 import org.openzen.zenscript.codemodel.identifiers.ModuleSymbol;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.codemodel.type.TypeMatcher;
+import org.openzen.zenscript.codemodel.type.member.MemberSet;
 
-public class ExpansionDefinition extends HighLevelDefinition {
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class ExpansionDefinition extends HighLevelDefinition implements ExpansionSymbol {
 	public TypeID target;
 
 	public ExpansionDefinition(CodePosition position, ModuleSymbol module, ZSPackage pkg, Modifiers modifiers) {
@@ -27,4 +38,22 @@ public <C, R> R accept(C context, DefinitionVisitorWithContext<C, R> visitor) {
 	public String getName() {
 		return "(expansion of " + target + ")";
 	}
+
+	@Override
+	public Optional<ResolvedType> resolve(TypeID expandingType) {
+		if (target == null)
+			throw new RuntimeException(position.toString() + ": Missing expansion target");
+
+		Map<TypeParameter, TypeID> mapping = TypeMatcher.match(expandingType, target);
+		if (mapping == null)
+			return Optional.empty();
+
+		TypeID[] expansionTypeArguments = Stream.of(typeParameters).map(mapping::get).toArray(TypeID[]::new);
+		MemberSet.Builder resolution = MemberSet.create();
+		GenericMapper mapper = new GenericMapper(mapping, expansionTypeArguments);
+		for (IDefinitionMember member : members)
+			member.registerTo(expandingType, resolution, mapper);
+
+		return Optional.of(resolution.build());
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/identifiers/ExpansionSymbol.java

@@ -1,5 +1,10 @@
 package org.openzen.zenscript.codemodel.identifiers;
 
-public interface ExpansionSymbol extends DefinitionSymbol {
+import org.openzen.zenscript.codemodel.compilation.ResolvedType;
+import org.openzen.zenscript.codemodel.type.TypeID;
+
+import java.util.Optional;
 
+public interface ExpansionSymbol extends DefinitionSymbol {
+	Optional<ResolvedType> resolve(TypeID expandingType);
 }

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeType.java

@@ -55,6 +55,8 @@ enum OperatorType {
 	@Target(ElementType.TYPE)
 	@interface Expansion {
 		String value();
+
+		//String[] typeParameters() default {};
 	}
 
 	@Retention(RetentionPolicy.RUNTIME)

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

@@ -28,6 +28,7 @@
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * @author Hoofdgebruiker
@@ -60,7 +61,7 @@ public JavaBytecodeModule compile(String packageName, SemanticModule module, Jav
 		context.addModule(module.module, target);
 
 		List<HighLevelDefinition> allDefinitions = new ArrayList<>(module.definitions.getAll());
-		allDefinitions.addAll(module.expansions);
+		allDefinitions.addAll(module.expansions.stream().filter(e -> e instanceof HighLevelDefinition).map(e -> (HighLevelDefinition) e).collect(Collectors.toList()));
 
 		for (HighLevelDefinition definition : allDefinitions) {
 			final String filename = this.mangler.mangleDefinitionName(definition);

JavaIntegration/src/main/java/org/openzen/zencode/java/ScriptingEngine.java

@@ -49,7 +49,7 @@ public class ScriptingEngine {
 	public final ScriptingEngineLogger logger;
 	public final ZSPackage root = ZSPackage.createRoot();
 	private final ModuleSpace space;
-	private final JavaNativeModuleSpace nativeSpace = new JavaNativeModuleSpace();
+	private final JavaNativeModuleSpace nativeSpace;
 	private final List<JavaNativeModule> nativeModules = new ArrayList<>();
 	private final List<SemanticModule> compiledModules = new ArrayList<>();
 	public boolean debug = false;
@@ -68,6 +68,7 @@ public ScriptingEngine(ScriptingEngineLogger logger, Function<String, InputStrea
 
 	public ScriptingEngine(ScriptingEngineLogger logger, Function<String, InputStream> resourceGetter, String... stdLibModulesToRegister) {
 		this.space = new ModuleSpace(new ArrayList<>());
+		this.nativeSpace = new JavaNativeModuleSpace(space);
 		this.logger = logger;
 
 		if(stdLibModulesToRegister.length == 0) {

JavaIntegration/src/main/java/org/openzen/zencode/java/impl/JavaNativeModuleSpace.java

@@ -1,16 +1,22 @@
 package org.openzen.zencode.java.impl;
 
 import org.openzen.zencode.java.module.JavaNativeModule;
+import org.openzen.zenscript.codemodel.ModuleSpace;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 
 public class JavaNativeModuleSpace {
+	public final ModuleSpace moduleSpace;
 	private final Map<String, JavaNativeModule> modulesByBasePackage = new HashMap<>();
 	private final Map<String, JavaNativeModule> moduleByPackage = new HashMap<>();
 	private final Map<Class<?>, JavaNativeModule> moduleByClass = new HashMap<>();
 
+	public JavaNativeModuleSpace(ModuleSpace moduleSpace) {
+		this.moduleSpace = moduleSpace;
+	}
+
 	public Optional<JavaNativeModule> getModule(Class<?> cls) {
 		if (moduleByClass.containsKey(cls))
 			return Optional.of(moduleByClass.get(cls));