Minor code reformat

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

 import stdlib.Strings;
 
 /**
- *
  * @author Stan Hebben
  */
 public class JavaNativeModule {
 			String name,
 			String basePackage,
 			GlobalTypeRegistry registry,
-			JavaNativeModule[] dependencies)
-	{
+			JavaNativeModule[] dependencies) {
 		this.pkg = pkg;
 		this.basePackage = basePackage;
 		module = new Module(name);
 	}
 	
 	private ZSPackage getPackage(String className) {
-		if (!className.contains("."))
+		//TODO make a lang package?
+		if (!className.contains(".") || className.startsWith("java.lang"))
 			return pkg;
 		
 		if (className.startsWith("."))
 				continue;
 			if (!isPublic(field.getModifiers()))
 				continue;
-
-			String fieldName = field.getName();
-			if (annotation != null && !annotation.value().isEmpty())
-				fieldName = annotation.value();
+			
+			final String fieldName = annotation.value().isEmpty() ? field.getName() : annotation.value();
 			
 			StoredType fieldType = loadStoredType(field.getAnnotatedType());
 			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, fieldName, thisType, fieldType, registry, 0, 0, null);
 		
 		boolean hasConstructor = false;
 		for (java.lang.reflect.Constructor constructor : cls.getConstructors()) {
-			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor)constructor.getAnnotation(ZenCodeType.Constructor.class);
+			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor) constructor.getAnnotation(ZenCodeType.Constructor.class);
 			if (constructorAnnotation != null) {
 				ConstructorMember member = asConstructor(definition, constructor);
 				definition.addMember(member);
 			AnnotatedType javaReturnType,
 			AnnotatedType[] parameterTypes,
 			TypeVariable<Method>[] javaTypeParameters,
-			AnnotatedType[] exceptionTypes)
-	{
+			AnnotatedType[] exceptionTypes) {
 		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(javaReturnType);
 		
 		FunctionParameter[] parameters = new FunctionParameter[parameterTypes.length];
 	
 	private TypeID loadType(Type type, boolean nullable, boolean unsigned) {
 		if (type instanceof Class) {
-			Class<?> classType = (Class<?>)type;
+			Class<?> classType = (Class<?>) type;
 			if (unsigned) {
 				if (unsignedByClass.containsKey(classType))
 					return unsignedByClass.get(classType);
 			HighLevelDefinition definition = addClass(classType);
 			return registry.getForDefinition(definition);
 		} else if (type instanceof ParameterizedType) {
-			ParameterizedType parameterizedType = (ParameterizedType)type;
-			Class<?> rawType = (Class)parameterizedType.getRawType();
+			ParameterizedType parameterizedType = (ParameterizedType) type;
+			Class<?> rawType = (Class) parameterizedType.getRawType();
 			
 			HighLevelDefinition definition = addClass(rawType);
 			Type[] parameters = parameterizedType.getActualTypeArguments();