Added loadMethod utility method for loading in a Method and retrieving its reference.

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

 import java.lang.reflect.TypeVariable;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Set;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 		}
 	}
 	
+	public FunctionalMemberRef loadStaticMethod(Method method) {
+		if (!isStatic(method.getModifiers()))
+			throw new IllegalArgumentException("Method is not static");
+		
+		HighLevelDefinition definition = addClass(method.getDeclaringClass());
+		JavaClass jcls = JavaClass.fromInternalName(getInternalName(method.getDeclaringClass()), JavaClass.Kind.CLASS);
+		
+		MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, method.getName(), getHeader(method), null);
+		definition.addMember(methodMember);
+		boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
+		compiled.setMethodInfo(methodMember, new JavaMethod(jcls, JavaMethod.Kind.STATIC, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), isGenericResult));
+		return methodMember.ref(registry.getForDefinition(definition).stored());
+	}
+	
 	private ZSPackage getPackage(String className) {
 		if (!className.contains("."))
 			return pkg;

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

 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.CompileException;
-import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenParser;

Parser/src/main/java/org/openzen/zenscript/parser/SimpleBracketSubParser.java → Parser/src/main/java/org/openzen/zenscript/parser/SimpleBracketParser.java

  *
  * @author Hoofdgebruiker
  */
-public class SimpleBracketSubParser implements BracketExpressionParser {
+public class SimpleBracketParser implements BracketExpressionParser {
 	private final FunctionalMemberRef method;
 	private final TypeID targetType;
 	
-	public SimpleBracketSubParser(GlobalTypeRegistry registry, FunctionalMemberRef method) {
+	public SimpleBracketParser(GlobalTypeRegistry registry, FunctionalMemberRef method) {
 		if (!method.isStatic())
 			throw new IllegalArgumentException("Method must be static");
 		if (method.getHeader().getNumberOfTypeParameters() > 0)

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

 		for (TestClass object : objects)
 			System.out.println("  - " + object.getName());
 	}
+	
+	public static String bracket(String value) {
+		return "BRACKET:" + value;
+	}
 }

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

 
 import java.io.File;
 import java.io.IOException;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 import org.openzen.zencode.java.JavaNativeModule;
 import org.openzen.zencode.java.ScriptingEngine;
-import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.lexer.ParseException;
-import org.openzen.zenscript.lexer.ZSToken;
-import org.openzen.zenscript.lexer.ZSTokenParser;
-import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.BracketExpressionParser;
-import org.openzen.zenscript.parser.expression.ParsedExpression;
-import org.openzen.zenscript.parser.expression.ParsedExpressionString;
+import org.openzen.zenscript.parser.SimpleBracketParser;
 
 public class Main {
-	public static void main(String[] args) throws CompileException, ParseException, IOException {
+	public static void main(String[] args) throws CompileException, ParseException, IOException, NoSuchMethodException {
 		ScriptingEngine scriptingEngine = new ScriptingEngine();
 		scriptingEngine.debug = true;
 		
 		for (int i = 0; i < inputFiles.length; i++)
 			sourceFiles[i] = new FileSourceFile(inputFiles[i].getName(), inputFiles[i]);
 		
+		BracketExpressionParser bracketParser = new SimpleBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("bracket", String.class)));
 		FunctionParameter parameter = new FunctionParameter(scriptingEngine.registry.getArray(StringTypeID.AUTO, 1).stored(), "args");
-		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, new TestBracketParser(), new FunctionParameter[] { parameter });
+		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, bracketParser, new FunctionParameter[] { parameter });
 		if (!scripts.isValid())
 			return;
 		
 		scriptArgs.put(parameter, new String[] { "hello", "world", "example" });
 		scriptingEngine.run(scriptArgs);
 	}
-	
-	private static class TestBracketParser implements BracketExpressionParser {
-		@Override
-		public ParsedExpression parse(CodePosition position, ZSTokenParser tokens) throws ParseException {
-			StringBuilder result = new StringBuilder();
-			while (tokens.optional(ZSTokenType.T_GREATER) == null) {
-				ZSToken token = tokens.next();
-				result.append(token.content);
-				result.append(tokens.getLastWhitespace());
-			}
-			
-			return new ParsedExpressionString(position.until(tokens.getPosition()), result.toString(), false);
-		}
-	}
 }

common.gradle

 apply plugin: 'maven'
 
 String mavenGroupId = 'org.openzen.zencode'
-String mavenVersion = '0.3.3'
+String mavenVersion = '0.3.5'
 
 sourceCompatibility = '1.8'
 [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'