Simplified dependencies and the build tree with some minor refactoring.

CompilerShared/src/main/java/org/openzen/zenscript/compiler/ModuleSpace.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/ModuleSpace.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.compiler;
+package org.openzen.zenscript.codemodel;
 
 import java.util.ArrayList;
 import java.util.HashMap;

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/SemanticModule.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.compiler;
+package org.openzen.zenscript.codemodel;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Module;
-import org.openzen.zenscript.codemodel.PackageDefinitions;
-import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
 import org.openzen.zenscript.codemodel.context.ModuleContext;
 import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
-import org.openzen.zenscript.validator.ValidationLogEntry;
-import org.openzen.zenscript.validator.Validator;
 
 /**
  *
 	public final String name;
 	public final SemanticModule[] dependencies;
 	
-	private State state;
+	public final State state;
 	public final Module module;
 	public final ZSPackage rootPackage;
 	public final ZSPackage modulePackage;
 				storageTypes);
 	}
 	
-	public boolean validate(Consumer<ValidationLogEntry> logger) {
-		if (state != State.NORMALIZED)
-			throw new IllegalStateException("Module is not yet normalized");
-		
-		Validator validator = new Validator(registry, expansions, annotations);
-		for (ScriptBlock script : scripts) {
-			validator.validate(script);
-		}
-		for (HighLevelDefinition definition : definitions.getAll()) {
-			validator.validate(definition);
-		}
-		
-		for (ValidationLogEntry entry : validator.getLog()) {
-			logger.accept(entry);
-		}
-		state = validator.hasErrors() ? State.INVALID : State.VALIDATED;
-		return !validator.hasErrors();
-	}
-	
-	public void compile(ZenCodeCompiler compiler) {
-		if (state != State.VALIDATED)
-			throw new IllegalStateException("Module is not yet validated");
-		
-		compiler.addModule(this);
-	}
-	
 	public ModuleContext getContext() {
 		return new ModuleContext(registry, module, expansions, rootPackage);
 	}

CompilerShared/src/main/java/org/openzen/zenscript/compiler/ModuleReference.java

  */
 package org.openzen.zenscript.compiler;
 
+import org.openzen.zenscript.codemodel.SemanticModule;
+
 /**
  *
  * @author Hoofdgebruiker

CompilerShared/src/main/java/org/openzen/zenscript/compiler/ModuleRegistry.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.SemanticModule;
 
 /**
  *

CompilerShared/src/main/java/org/openzen/zenscript/compiler/Target.java

  */
 package org.openzen.zenscript.compiler;
 
+import org.openzen.zenscript.codemodel.SemanticModule;
+
 /**
  *
  * @author Hoofdgebruiker

CompilerShared/src/main/java/org/openzen/zenscript/compiler/ZenCodeCompiler.java

  */
 package org.openzen.zenscript.compiler;
 
+import org.openzen.zenscript.codemodel.SemanticModule;
+
 /**
  *
  * @author Hoofdgebruiker

Constructor/src/main/java/org/openzen/zenscript/constructor/ConstructorRegistry.java

 import java.util.List;
 import java.util.Map;
 import org.json.JSONObject;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.TargetType;
 import org.openzen.zenscript.compiler.ZenCodeCompiler;

Constructor/src/main/java/org/openzen/zenscript/constructor/ModuleLoader.java

 import java.util.Stack;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.ModuleReference;
-import org.openzen.zenscript.compiler.SemanticModule;
 
 /**
  *

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

  */
 package org.openzen.zenscript.constructor.module;
 
-import org.openzen.zenscript.compiler.ModuleSpace;
-import org.openzen.zenscript.compiler.SemanticModule;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.ModuleSpace;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleReference.java

 
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.constructor.ModuleLoader;
 
 /**

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalModule.java

 package org.openzen.zenscript.ide.host.local;
 
 import java.util.function.Consumer;
-import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.ide.codemodel.IDECodeError;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEPackage;
+import org.openzen.zenscript.validator.Validator;
 
 /**
  *
 	@Override
 	public void prebuild(ModuleLoader loader, Consumer<IDECodeError> errors) {
 		SemanticModule module = loader.getModule(this.module.getName());
-		module.validate(entry -> errors.accept(new IDECodeError(null, entry.position, entry.message)));
+		Validator.validate(module, entry -> errors.accept(new IDECodeError(null, entry.position, entry.message)));
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.java

 import java.util.Set;
 import java.util.Stack;
 import java.util.function.Consumer;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.constructor.Project;
 import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.ide.host.IDETarget;
 import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
 import org.openzen.zenscript.ide.ui.view.output.OutputLine;
 import org.openzen.zenscript.validator.ValidationLogEntry;
+import org.openzen.zenscript.validator.Validator;
 import stdlib.Strings;
 
 /**
 			}
 			
 			SemanticModule module = moduleLoader.getModule(target.getModule());
-			module = module.normalize();
-			module.validate(validationLogger);
+			module = Validator.validate(module.normalize(), validationLogger);
 			
 			ZenCodeCompiler compiler = target.createCompiler(module);
 			if (!module.isValid())
 				return compiler;
 			
 			SemanticModule stdlib = moduleLoader.getModule("stdlib");
-			stdlib = stdlib.normalize();
-			stdlib.validate(validationLogger);
+			stdlib = Validator.validate(stdlib.normalize(), validationLogger);
 			if (!stdlib.isValid())
 				return compiler;
 			
-			stdlib.compile(compiler);
+			compiler.addModule(stdlib);
 			compiledModules.add(stdlib.name);
 			
 			boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, new Stack<>(), module, validationLogger);
 			if (!isValid)
 				return compiler;
 			
-			module.compile(compiler);
+			compiler.addModule(module);
 			compiler.finish();
 			return compiler;
 		} catch (Exception ex) {
 				return false;
 			}
 			
-			dependency = dependency.normalize();
-			dependency.validate(logger);
+			dependency = Validator.validate(dependency.normalize(), logger);
 			if (!dependency.isValid()) {
 				compilingModules.pop();
 				return false;
 				return false;
 			}
 			
-			dependency.compile(compiler);
+			compiler.addModule(dependency);
 			compilingModules.pop();
 		}
 		

JavaAnnotations/build.gradle

 }
 
 dependencies {
-    // TODO: Add dependencies here
-    //   but note that JUnit should have already been added in parent.gradle.
-    //   By default, only the Maven Central Repository is specified in
-    //   parent.gradle.
-    //
-    // You can read more about how to add dependency here:
-    //   http://www.gradle.org/docs/current/userguide/dependency_management.html#sec:how_to_declare_your_dependencies
+    // no dependencies
 }

JavaBytecodeCompiler/build.gradle

 dependencies {
 	compile 'org.ow2.asm:asm-debug-all:6.0_BETA'
 	compile project(':CodeModel')
-	compile project(':CompilerShared')
 	compile project(':JavaShared')
 }

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

 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javabytecode.compiler.JavaClassWriter;
 import org.openzen.zenscript.javabytecode.compiler.JavaScriptFile;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;

JavaIntegration/build.gradle

 
 dependencies {
 	compile project(':CodeModel')
-	compile project(':CompilerShared')
 	compile project(':Parser')
 	compile project(':JavaBytecodeCompiler')
 	compile project(':JavaAnnotations')
+	compile project(':Validator')
 }

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

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
-import org.openzen.zenscript.compiler.ModuleSpace;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;

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

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.ModuleSpace;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
-import org.openzen.zenscript.compiler.ModuleSpace;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javabytecode.JavaBytecodeRunUnit;
 import org.openzen.zenscript.javabytecode.JavaCompiler;
 import org.openzen.zenscript.javashared.SimpleJavaCompileSpace;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
 import org.openzen.zenscript.parser.ZippedPackage;
+import org.openzen.zenscript.validator.Validator;
 
 /**
  *
 		try {
 			ZippedPackage stdlibs = new ZippedPackage(ScriptingEngine.class.getResourceAsStream("/StdLibs.zip"));
 			SemanticModule stdlibModule = stdlibs.loadModule(space, "stdlib", null, new SemanticModule[0], stdlib);
-			stdlibModule.validate(error -> System.out.println(error.toString()));
+			stdlibModule = Validator.validate(stdlibModule, error -> System.out.println(error.toString()));
 			space.addModule("stdlib", stdlibModule);
 		} catch (IOException ex) {
 			throw new RuntimeException(ex);
 	}
 	
 	public void registerNativeProvided(JavaNativeModule module) throws CompileException {
-		SemanticModule semantic = module.toSemantic(space);
-		if (!semantic.validate(entry -> System.out.println(entry)))
+		SemanticModule semantic = Validator.validate(
+				module.toSemantic(space),
+				entry -> System.out.println(entry));
+		if (!semantic.isValid())
 			return;
 		
 		space.addModule(module.module.name, semantic);
 		if (!scripts.isValid())
 			return scripts;
 		
-		scripts = scripts.normalize();
-		if (!scripts.validate(error -> System.out.println(error.toString())))
-			return scripts;
-		
-		return scripts;
+		return Validator.validate(
+				scripts.normalize(),
+				error -> System.out.println(error.toString()));
 	}
 	
 	public void registerCompiled(SemanticModule module) {

JavaShared/build.gradle

 
 dependencies {
 	compile project(':CodeModel')
-	compile project(':CompilerShared')
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaBaseCompiler.java

 package org.openzen.zenscript.javashared;
 
-import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.compiler.ZenCodeCompiler;
-
 /*
  * To change this license header, choose License Headers in Project Properties.
  * To change this template file, choose Tools | Templates
  *
  * @author Hoofdgebruiker
  */
-public abstract class JavaBaseCompiler implements ZenCodeCompiler {
+public abstract class JavaBaseCompiler {
 	//public abstract JavaCompiledModule compile(SemanticModule module, JavaCompileSpace space);
 }

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.TypeID;
 import org.openzen.zenscript.compiler.CompileScope;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javashared.JavaClass;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaMemberCompiler.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceCompiler.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionVisitor;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompileSpace;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceFile.java

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.annotations.NativeTag;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.prepare.JavaPrepareDefinitionMemberVisitor;
 

Parser/build.gradle

 dependencies {
     compile project(':Shared')
 	compile project(':CodeModel')
-	compile project(':CompilerShared')
 }

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.ModuleSpace;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.WhitespacePostComment;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.FileResolutionContext;
 import org.openzen.zenscript.codemodel.scope.GlobalScriptScope;
 import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.scope.StatementScope;
-import org.openzen.zenscript.compiler.ModuleSpace;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.statements.ParsedStatement;
 

Parser/src/main/java/org/openzen/zenscript/parser/ZippedPackage.java

 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.ModuleSpace;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.compiler.ModuleSpace;
-import org.openzen.zenscript.compiler.SemanticModule;
 import org.openzen.zenscript.lexer.ParseException;
 
 /**

ScriptingExample/build.gradle

 }
 
 dependencies {
-	compile project(':Parser')
-	compile project(':JavaBytecodeCompiler')
-	compile project(':JavaShared')
-	compile project(':CodeFormatter')
     compile project(':JavaIntegration')
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;

Validator/src/main/java/org/openzen/zenscript/validator/Validator.java

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Consumer;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.statement.Statement;
  * @author Hoofdgebruiker
  */
 public class Validator {
+	public static SemanticModule validate(SemanticModule module, Consumer<ValidationLogEntry> logger) {
+		if (module.state != SemanticModule.State.NORMALIZED)
+			throw new IllegalStateException("Module is not yet normalized");
+		
+		Validator validator = new Validator(module.registry, module.expansions, module.annotations);
+		for (ScriptBlock script : module.scripts) {
+			validator.validate(script);
+		}
+		for (HighLevelDefinition definition : module.definitions.getAll()) {
+			validator.validate(definition);
+		}
+		
+		for (ValidationLogEntry entry : validator.getLog()) {
+			logger.accept(entry);
+		}
+		
+		SemanticModule.State state = validator.hasErrors() ? SemanticModule.State.INVALID : SemanticModule.State.VALIDATED;
+		return new SemanticModule(
+				module.module,
+				module.dependencies,
+				state,
+				module.rootPackage,
+				module.modulePackage,
+				module.definitions,
+				module.scripts,
+				module.registry,
+				module.expansions,
+				module.annotations,
+				module.storageTypes);
+	}
+	
 	private final List<ValidationLogEntry> log = new ArrayList<>();
 	public final GlobalTypeRegistry registry;
 	public final List<ExpansionDefinition> expansions;