- Starting work on improving type parameter usage in generic methods

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

 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
+	public boolean[] useTypeParameters() {
+		boolean[] useTypeParameters = new boolean[typeParameters.length];
+		for (int i = 0; i < useTypeParameters.length; i++)
+			useTypeParameters[i] = true;
+		
+		return useTypeParameters;
+	}
+	
 	public StoredType getReturnType() {
 		return returnType;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java

 	
 	@Override
 	public <C, R, E extends Exception> R accept(C context, TypeVisitorWithContext<C, R, E> visitor) throws E {
-		return visitor.visitModified(context, this);
+		return visitor.visitOptional(context, this);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeMatcher.java

 	}
 
 	@Override
-	public Boolean visitModified(Matching context, OptionalTypeID type) {
+	public Boolean visitOptional(Matching context, OptionalTypeID type) {
 		if (context.type.type instanceof OptionalTypeID) {
 			OptionalTypeID modified = (OptionalTypeID) context.type.type;
 			return match(context, modified.baseType.stored(), type.baseType.stored());

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeVisitorWithContext.java

 	
 	R visitRange(C context, RangeTypeID range) throws E;
 	
-	R visitModified(C context, OptionalTypeID type) throws E;
+	R visitOptional(C context, OptionalTypeID type) throws E;
 	
 	default R visitInvalid(C context, InvalidTypeID type) throws E {
 		throw new RuntimeException("Invalid type: " + type.message);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

 	}
 
 	@Override
-	public Void visitModified(Void context, OptionalTypeID modified) {
+	public Void visitOptional(Void context, OptionalTypeID modified) {
 		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "modified", Modifiers.PUBLIC, null);
 		modified.baseType.accept(context, this);
 		

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

  * @author Hoofdgebruiker
  */
 public class JavaBytecodeContext extends JavaContext {
-	private final JavaBytecodeModule target;
+	public final JavaBytecodeModule target;
 	private final TypeGenerator typeGenerator;
 	private final JavaTypeInternalNameVisitor internalNameVisitor;
 	private final JavaTypeDescriptorVisitor descriptorVisitor;

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/CompilerUtils.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.switchvalue.*;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
+import org.openzen.zenscript.javashared.JavaTypeParameterInfo;
 
 public class CompilerUtils {
 
 
     public static void tagMethodParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isStatic) {
 		int index = header.getNumberOfTypeParameters();
-		
+		for (int i = 0; i < header.typeParameters.length; i++) {
+			TypeParameter parameter = header.typeParameters[i];
+			module.setTypeParameterInfo(parameter, new JavaTypeParameterInfo(index++));
+		}
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
             String parameterType = context.getDescriptor(parameter.type);
         }
     }
 
-    public static void tagConstructorParameters(JavaBytecodeContext context, JavaCompiledModule module, FunctionHeader header, boolean isEnum) {
+    public static void tagConstructorParameters(JavaBytecodeContext context, JavaCompiledModule module, HighLevelDefinition definition, FunctionHeader header, boolean isEnum) {
+		int index = header.getNumberOfTypeParameters();
+		for (int i = 0; i < definition.typeParameters.length; i++) {
+			JavaTypeParameterInfo info = module.getTypeParameterInfo(definition.typeParameters[i]);
+			if (info.field != null)
+				index++;
+		}
+		for (int i = 0; i < header.typeParameters.length; i++) {
+			TypeParameter parameter = header.typeParameters[i];
+			module.setTypeParameterInfo(parameter, new JavaTypeParameterInfo(index++));
+		}
         for (int i = 0; i < header.parameters.length; i++) {
             FunctionParameter parameter = header.parameters[i];
             String parameterType = context.getDescriptor(parameter.type);

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaBoxingTypeVisitor.java

 	}
 
 	@Override
-	public Void visitModified(StoredType context, OptionalTypeID type) {
+	public Void visitOptional(StoredType context, OptionalTypeID type) {
 		//NO-OP
 		return null;
 	}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

 		BuiltinID builtin = expression.member.getBuiltin();
 		if (builtin == null) {
 			expression.target.accept(this);
+			
+			JavaMethod methodInfo = context.getJavaMethod(expression.member);
+			for (int i = 0; i < expression.arguments.typeArguments.length; i++) {
+				if (methodInfo.typeParameterArguments[i]) {
+					StoredType arguments = expression.arguments.typeArguments[i];
+					
+				}
+			}
 			for (Expression argument : expression.arguments.arguments) {
 				argument.accept(this);
 			}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaTypeExpressionVisitor.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javabytecode.compiler;
+
+import java.util.Iterator;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.type.ArrayTypeID;
+import org.openzen.zenscript.codemodel.type.AssocTypeID;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.FunctionTypeID;
+import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
+import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.IteratorTypeID;
+import org.openzen.zenscript.codemodel.type.OptionalTypeID;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.TypeVisitorWithContext;
+import org.openzen.zenscript.javabytecode.JavaBytecodeContext;
+import org.openzen.zenscript.javashared.JavaTypeParameterInfo;
+
+/**
+ *
+ * @author Stan Hebben
+ */
+public class JavaTypeExpressionVisitor implements TypeVisitorWithContext<JavaWriter, Void, RuntimeException> {
+	private final JavaBytecodeContext context;
+	
+	public JavaTypeExpressionVisitor(JavaBytecodeContext context) {
+		this.context = context;
+	}
+
+	@Override
+	public Void visitBasic(JavaWriter writer, BasicTypeID basic) {
+		switch (basic) {
+			case BOOL:
+				writer.constant(Boolean.class);
+				return null;
+			case SBYTE:
+				writer.constant(Byte.class);
+				return null;
+			case SHORT:
+				writer.constant(Short.class);
+				return null;
+			case BYTE:
+			case USHORT:
+			case INT:
+			case UINT:
+			case USIZE:
+				writer.constant(Integer.class);
+				return null;
+			case LONG:
+			case ULONG:
+				writer.constant(Long.class);
+				return null;
+			case FLOAT:
+				writer.constant(Float.class);
+				return null;
+			case DOUBLE:
+				writer.constant(Double.class);
+				return null;
+			case CHAR:
+				writer.constant(Character.class);
+				return null;
+			default:
+				throw new IllegalArgumentException();
+		}
+	}
+
+	@Override
+	public Void visitString(JavaWriter writer, StringTypeID string) {
+		writer.constant(String.class);
+		return null;
+	}
+
+	@Override
+	public Void visitArray(JavaWriter writer, ArrayTypeID array) {
+		throw new UnsupportedOperationException("Not yet implemented");
+	}
+
+	@Override
+	public Void visitAssoc(JavaWriter writer, AssocTypeID assoc) {
+		writer.constant(Map.class);
+		return null;
+	}
+
+	@Override
+	public Void visitGenericMap(JavaWriter writer, GenericMapTypeID map) {
+		writer.constant(Map.class);
+		return null;
+	}
+
+	@Override
+	public Void visitIterator(JavaWriter writer, IteratorTypeID iterator) {
+		writer.constant(Iterator.class);
+		return null;
+	}
+
+	@Override
+	public Void visitFunction(JavaWriter writer, FunctionTypeID function) {
+		writer.constantClass(context.getFunction(function).getCls());
+		return null;
+	}
+
+	@Override
+	public Void visitDefinition(JavaWriter writer, DefinitionTypeID definition) {
+		writer.constantClass(context.getJavaClass(definition.definition));
+		return null;
+	}
+
+	@Override
+	public Void visitGeneric(JavaWriter writer, GenericTypeID generic) {
+		JavaTypeParameterInfo info = context.target.getTypeParameterInfo(generic.parameter);
+		if (info.field != null) {
+			writer.loadObject(0); // this
+			writer.getField(info.field);
+		} else {
+			writer.loadObject(info.parameterIndex);
+		}
+		return null;
+	}
+
+	@Override
+	public Void visitRange(JavaWriter writer, RangeTypeID range) {
+		writer.constantClass(context.getRange(range).cls);
+		return null;
+	}
+
+	@Override
+	public Void visitOptional(JavaWriter writer, OptionalTypeID type) {
+		return type.baseType.accept(writer, this);
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaWriter.java

 
         visitor.visitLdcInsn(value);
     }
+	
+	public void constantClass(JavaClass cls) {
+		visitor.visitLdcInsn(Type.getType(cls.internalName));
+	}
 
     public void pop() {
         if (debug)

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaMemberVisitor.java

         final Label constructorEnd = new Label();
         final JavaWriter constructorWriter = new JavaWriter(member.position, writer, method, definition, context.getMethodSignature(member.header), null);
         constructorWriter.label(constructorStart);
-        CompilerUtils.tagConstructorParameters(context, javaModule, member.header, isEnum);
+        CompilerUtils.tagConstructorParameters(context, javaModule, member.definition, member.header, isEnum);
         for (FunctionParameter parameter : member.header.parameters) {
             constructorWriter.nameVariable(
                     javaModule.getParameterInfo(parameter).index,

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

 
 /**
  *
- * @author Hoofdgebruiker
+ * @author Stan Hebben
  */
 public class JavaNativeModule {
 	public final Module module;
 	private final ZSPackage pkg;
 	private final String basePackage;
 	private final GlobalTypeRegistry registry;
-	private final boolean allowNonAnnonated;
 	private final PackageDefinitions definitions = new PackageDefinitions();
 	private final JavaCompiledModule compiled;
 	
 			String name,
 			String basePackage,
 			GlobalTypeRegistry registry,
-			boolean allowNonAnnotated,
 			JavaNativeModule[] dependencies)
 	{
 		this.pkg = pkg;
 			definitionByClass.putAll(dependency.definitionByClass);
 		}
 		
-		this.allowNonAnnonated = allowNonAnnotated;
 		compiled = new JavaCompiledModule(module, FunctionParameter.NONE);
 		
 		typeByClass.put(void.class, BasicTypeID.VOID);
 		if (definitionByClass.containsKey(cls))
 			return definitionByClass.get(cls);
 		
-		HighLevelDefinition result = addClass(cls, ZenCodeType.class.isAssignableFrom(cls));
+		HighLevelDefinition result = convertClass(cls);
 		definitionByClass.put(cls, result);
 		return result;
 	}
 		return classPkg;
 	}
 	
-	private <T> HighLevelDefinition addClass(Class<T> cls, boolean annotated) {
-		if (!annotated && !allowNonAnnonated)
-			throw new IllegalArgumentException("This class is not annotated as ZenCode class");
+	private <T> HighLevelDefinition convertClass(Class<T> cls) {
 		if ((cls.getModifiers() & Modifier.PUBLIC) == 0)
 			throw new IllegalArgumentException("Class must be public");
 		
 		StoredType thisType = new StoredType(registry.getForMyDefinition(definition), AutoStorageTag.INSTANCE);
 		for (Field field : cls.getDeclaredFields()) {
 			ZenCodeType.Field annotation = field.getAnnotation(ZenCodeType.Field.class);
-			if (annotated && annotation == null)
+			if (annotation == null)
 				continue;
 			if (!isPublic(field.getModifiers()))
 				continue;
 		boolean hasConstructor = false;
 		for (java.lang.reflect.Constructor constructor : cls.getConstructors()) {
 			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor)constructor.getAnnotation(ZenCodeType.Constructor.class);
-			if (constructorAnnotation != null || !annotated) {
+			if (constructorAnnotation != null) {
 				ConstructorMember member = asConstructor(definition, constructor);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, constructor));
 			}
 			
 			ZenCodeType.Getter getter = method.getAnnotation(ZenCodeType.Getter.class);
-			if (getter != null || (!annotated && isGetterName(method.getName()) && method.getParameterCount() == 0)) {
+			if (getter != null) {
 				GetterMember member = asGetter(definition, method, getter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.getType()));
 			}
 			
 			ZenCodeType.Setter setter = method.getAnnotation(ZenCodeType.Setter.class);
-			if (setter != null || (!annotated && method.getName().startsWith("set") && method.getParameterCount() == 1)) {
+			if (setter != null) {
 				SetterMember member = asSetter(definition, method, setter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
 				continue;
 			}
 			
-			if (!annotated) {
+			/*if (!annotated) {
 				MethodMember member = asMethod(definition, method, null);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
-			}
+			}*/
 		}
 		
 		return definition;

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

 	
 	public JavaNativeModule createNativeModule(String name, String basePackage, JavaNativeModule... dependencies) {
 		ZSPackage testPackage = new ZSPackage(space.rootPackage, name);
-		return new JavaNativeModule(testPackage, name, basePackage, registry, false, dependencies);
+		return new JavaNativeModule(testPackage, name, basePackage, registry, dependencies);
 	}
 	
 	public void registerNativeProvided(JavaNativeModule module) throws CompileException {

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

 import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 	private final Map<ImplementationMember, JavaImplementation> implementations = new HashMap<>();
 	private final Map<IDefinitionMember, JavaField> fields = new HashMap<>();
 	private final Map<IDefinitionMember, JavaMethod> methods = new HashMap<>();
+	private final Map<TypeParameter, JavaTypeParameterInfo> typeParameters = new HashMap<>();
 	private final Map<FunctionParameter, JavaParameterInfo> parameters = new HashMap<>();
 	private final Map<VariantDefinition.Option, JavaVariantOption> variantOptions = new HashMap<>();
 	
 		return method;
 	}
 	
+	public void setTypeParameterInfo(TypeParameter parameter, JavaTypeParameterInfo info) {
+		typeParameters.put(parameter, info);
+	}
+	
+	public JavaTypeParameterInfo getTypeParameterInfo(TypeParameter parameter) {
+		JavaTypeParameterInfo info = typeParameters.get(parameter);
+		if (info == null)
+			throw new IllegalStateException("Missing parameter info for type parameter " + parameter);
+		
+		return info;
+	}
+	
 	public void setParameterInfo(FunctionParameter parameter, JavaParameterInfo info) {
 		parameters.put(parameter, info);
 	}

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

 	public final String descriptor;
 	public final int modifiers;
 	public final boolean genericResult;
+	public final boolean[] typeParameterArguments;
 	
 	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers, boolean genericResult) {
+		this(cls, kind, name, compile, descriptor, modifiers, genericResult, new boolean[0]);
+	}
+	
+	public JavaMethod(JavaClass cls, Kind kind, String name, boolean compile, String descriptor, int modifiers, boolean genericResult, boolean[] typeParameterArguments) {
 		if (descriptor.contains("<")) // fix signature bug
 			throw new IllegalArgumentException("Invalid descriptor!");
 		
 		this.descriptor = descriptor;
 		this.modifiers = modifiers;
 		this.genericResult = genericResult;
+		this.typeParameterArguments = typeParameterArguments;
 	}
 	
 	public JavaMethod(JavaNativeTranslation<?> translation) {
 		this.descriptor = "";
 		this.modifiers = 0;
 		this.genericResult = false;
+		this.typeParameterArguments = new boolean[0];
 	}
 	
 	public String getMapping(JavaClass definition) {

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

 	}
 
 	@Override
-	public String visitModified(StoredType context, OptionalTypeID type) {
+	public String visitOptional(StoredType context, OptionalTypeID type) {
 		StringBuilder result = new StringBuilder();
 		if (type.isOptional())
 			result.append("Optional");

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

 	}
 
 	@Override
-	public String visitModified(StoredType context, OptionalTypeID type) {
+	public String visitOptional(StoredType context, OptionalTypeID type) {
 		return type.baseType.accept(context, this);
 	}
 }

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

 		}
 
 		@Override
-		public JavaTypeInfo visitModified(StoredType context, OptionalTypeID type) {
+		public JavaTypeInfo visitOptional(StoredType context, OptionalTypeID type) {
 			return type.baseType.accept(null, this);
 		}
 	}

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

     }
 
     @Override
-    public String visitModified(StoredType context, OptionalTypeID modified) {
+    public String visitOptional(StoredType context, OptionalTypeID modified) {
 		if (modified.isOptional())
 			return modified.withoutOptional().accept(context, forOptional);
 		

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

 	}
 
 	@Override
-	public String visitModified(StoredType context, OptionalTypeID type) {
+	public String visitOptional(StoredType context, OptionalTypeID type) {
 		StringBuilder result = new StringBuilder();
 		if (type.isOptional())
 			result.append("Optional");

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.javashared;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaTypeParameterInfo {
+	public final int parameterIndex;
+	public final JavaField field;
+	
+	public JavaTypeParameterInfo(int parameterIndex) {
+		this.parameterIndex = parameterIndex;
+		this.field = null;
+	}
+	
+	public JavaTypeParameterInfo(JavaField field) {
+		this.parameterIndex = -1;
+		this.field = field;
+	}
+}

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 			DefinitionMemberRef base = member.getOverrides();
 			
 			JavaMethod baseMethod = context.getJavaMethod(base.getTarget());
+			
 			method = new JavaMethod(
 					cls,
 					baseMethod.kind,
 					true,
 					context.getMethodDescriptor(header),
 					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
-					header.getReturnType().type instanceof GenericTypeID);
+					header.getReturnType().type instanceof GenericTypeID,
+					header.useTypeParameters());
 		} else if (method == null) {
 			method = new JavaMethod(
 					cls,
 					true,
 					context.getMethodDescriptor(header),
 					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
-					header.getReturnType().type instanceof GenericTypeID);
+					header.getReturnType().type instanceof GenericTypeID,
+					header.useTypeParameters());
 		}
 		
 		if (method.compile && member.getBuiltin() != BuiltinID.CLASS_DEFAULT_CONSTRUCTOR) {

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareExpansionMethodVisitor.java

 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		if (method == null)
-			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(header), JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()), header.getReturnType().type instanceof GenericTypeID); 
+			method = new JavaMethod(
+					cls,
+					getKind(member),
+					name,
+					true,
+					context.getMethodDescriptor(header),
+					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
+					header.getReturnType().type instanceof GenericTypeID,
+					header.useTypeParameters()); 
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/TypeSerializer.java

 	}
 
 	@Override
-	public Void visitModified(TypeContext context, OptionalTypeID type) {
+	public Void visitOptional(TypeContext context, OptionalTypeID type) {
 		if (type.isOptional()) {
 			output.writeUInt(TypeEncoding.TYPE_OPTIONAL);
 			type.withoutOptional().accept(context, this);

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

 	}
 
 	@Override
-	public Void visitModified(TypeContext context, OptionalTypeID type) {
+	public Void visitOptional(TypeContext context, OptionalTypeID type) {
 		// TODO: detect duplicate const
 		validate(context, type.baseType);
 		return null;

common.gradle

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