Skip to content

Commit

Permalink
Removed the unnecessary unsigned parameters
Browse files Browse the repository at this point in the history
  • Loading branch information
@stanhebben
stanhebben committed Jan 31, 2025
1 parent e782c6a commit 2382bab
Showing 1 changed file with 24 additions and 31 deletions.
55 changes: 24 additions & 31 deletions .../src/main/java/org/openzen/zencode/java/impl/conversion/JavaRuntimeTypeConverterImpl.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,13 +7,11 @@
import org.openzen.zencode.java.TypeVariableContext;
import org.openzen.zencode.java.module.JavaAnnotatedType;
import org.openzen.zencode.java.module.JavaNativePackageInfo;
import org.openzen.zencode.java.module.JavaRuntimeClass;
import org.openzen.zencode.shared.CodePosition;
import org.openzen.zencode.shared.LiteralSourceFile;
import org.openzen.zenscript.codemodel.FunctionHeader;
import org.openzen.zenscript.codemodel.GenericMapper;
import org.openzen.zenscript.codemodel.Modifiers;
import org.openzen.zenscript.codemodel.ModuleSpace;
import org.openzen.zenscript.codemodel.compilation.CompileContext;
import org.openzen.zenscript.codemodel.definition.ClassDefinition;
import org.openzen.zenscript.codemodel.definition.ZSPackage;
Expand Down Expand Up @@ -68,7 +66,7 @@ public TypeID getType(TypeVariableContext context, AnnotatedType type) {
} else if (type.isAnnotationPresent(ZenCodeType.USize.class)) {
result = BasicTypeID.USIZE;
} else {
result = loadType(context, JavaAnnotatedType.of(type), false);
result = loadType(context, JavaAnnotatedType.of(type));
}

return optionallyWrap(type, result);
Expand Down Expand Up @@ -101,19 +99,19 @@ public TypeID parseType(String type) {
}
}

private TypeID loadType(TypeVariableContext context, JavaAnnotatedType type, boolean unsigned) {
private TypeID loadType(TypeVariableContext context, JavaAnnotatedType type) {
final JavaAnnotatedType.ElementType elementType = type.getElementType();

try {
switch (elementType) {
case ANNOTATED_PARAMETERIZED_TYPE:
return loadAnnotatedParameterizedType(context, (AnnotatedParameterizedType) type.getAnnotatedElement(), unsigned);
return loadAnnotatedParameterizedType(context, (AnnotatedParameterizedType) type.getAnnotatedElement());
case ANNOTATED_TYPE:
return loadAnnotatedType(context, (AnnotatedType) type.getAnnotatedElement(), unsigned);
return loadAnnotatedType(context, (AnnotatedType) type.getAnnotatedElement());
case CLASS:
return loadClass(context, (Class<?>) type.getType(), unsigned);
return loadClass(context, (Class<?>) type.getType());
case GENERIC_ARRAY:
return loadGenericArray(context, (GenericArrayType) type.getType(), unsigned);
return loadGenericArray(context, (GenericArrayType) type.getType());
case PARAMETERIZED_TYPE:
return loadParameterizedType(context, (ParameterizedType) type.getType());
case TYPE_VARIABLE:
Expand All @@ -128,57 +126,52 @@ private TypeID loadType(TypeVariableContext context, JavaAnnotatedType type, boo
throw new IllegalArgumentException("Invalid type " + elementType + ": not yet implemented or foolery");
}

private TypeSymbol loadRawType(TypeVariableContext context, JavaAnnotatedType type, boolean unsigned) {
private TypeSymbol loadRawType(JavaAnnotatedType type) {
final JavaAnnotatedType.ElementType elementType = type.getElementType();

try {
switch (elementType) {
case CLASS:
return findType((Class<?>) type.getType());
default:
throw new IllegalArgumentException("Didn't expect to get this kind of type: " + type);
if (Objects.requireNonNull(elementType) == JavaAnnotatedType.ElementType.CLASS) {
return findType((Class<?>) type.getType());
}
throw new IllegalArgumentException("Didn't expect to get this kind of type: " + type);
} catch (final IllegalArgumentException e) {
throw new IllegalArgumentException("Unable to analyze type: " + type, e);
}
}

private TypeID loadAnnotatedParameterizedType(TypeVariableContext context, AnnotatedParameterizedType type, boolean unsigned) {
private TypeID loadAnnotatedParameterizedType(TypeVariableContext context, AnnotatedParameterizedType type) {
final ParameterizedType parameterizedType = this.getTypeIfValid(JavaAnnotatedType.of(type.getType()), JavaAnnotatedType.ElementType.PARAMETERIZED_TYPE);
final JavaAnnotatedType rawType = JavaAnnotatedType.of(parameterizedType.getRawType());

final JavaAnnotatedType[] actualTypeArguments = JavaAnnotatedType.arrayOf(type.getAnnotatedActualTypeArguments());
final TypeID[] codeParameters = new TypeID[actualTypeArguments.length];

for (int i = 0; i < actualTypeArguments.length; i++) {
codeParameters[i] = this.loadType(context, actualTypeArguments[i], false);
codeParameters[i] = this.loadType(context, actualTypeArguments[i]);
}

if (rawType.getElementType() == JavaAnnotatedType.ElementType.CLASS) {
//noinspection SuspiciousMethodCalls
if (specialTypes.containsKey(rawType.getType())) {
//noinspection SuspiciousMethodCalls
return specialTypes.get(rawType.getType()).apply(codeParameters);
}

final TypeSymbol rawTypeSymbol = loadRawType(context, rawType, unsigned);
final TypeSymbol rawTypeSymbol = loadRawType(rawType);
return DefinitionTypeID.create(rawTypeSymbol, codeParameters);
}
return this.loadType(context, JavaAnnotatedType.of(type), unsigned);
return this.loadType(context, JavaAnnotatedType.of(type));
}

private TypeID loadAnnotatedType(TypeVariableContext context, AnnotatedType type, boolean unsigned) {
private TypeID loadAnnotatedType(TypeVariableContext context, AnnotatedType type) {
final JavaAnnotatedType annotatedType = JavaAnnotatedType.of(type.getType());
TypeID result = this.loadType(context, annotatedType, unsigned);
TypeID result = this.loadType(context, annotatedType);
return optionallyWrap(type, result);
}

private TypeID loadClass(TypeVariableContext context, Class<?> type, boolean unsigned) {
if (unsigned) {
return unsignedByClass.computeIfAbsent(type, it -> {
throw new IllegalArgumentException("This class cannot be used as unsigned: " + it);
});
}
private TypeID loadClass(TypeVariableContext context, Class<?> type) {
if (type.isArray()) {
final TypeID baseType = this.loadType(context, JavaAnnotatedType.of(type.getComponentType()), false);
final TypeID baseType = this.loadType(context, JavaAnnotatedType.of(type.getComponentType()));
return new ArrayTypeID(baseType);
}
if (type.isAnnotationPresent(FunctionalInterface.class)) {
Expand All @@ -201,9 +194,9 @@ private TypeID loadClass(TypeVariableContext context, Class<?> type, boolean uns
return DefinitionTypeID.create(definition, typeParameters.toArray(TypeID.NONE));
}

private TypeID loadGenericArray(TypeVariableContext context, GenericArrayType type, boolean unsigned) {
private TypeID loadGenericArray(TypeVariableContext context, GenericArrayType type) {
final JavaAnnotatedType componentType = JavaAnnotatedType.of(type.getGenericComponentType());
final TypeID baseType = this.loadType(context, componentType, unsigned);
final TypeID baseType = this.loadType(context, componentType);
return new ArrayTypeID(baseType);
}

Expand All @@ -217,7 +210,7 @@ private TypeID loadParameterizedType(TypeVariableContext context, ParameterizedT

TypeID[] codeParameters = new TypeID[typeArguments.length];
for (int i = 0; i < typeArguments.length; i++) {
codeParameters[i] = this.loadType(context, typeArguments[i], false);
codeParameters[i] = this.loadType(context, typeArguments[i]);
}

if (rawType == Map.class) {
Expand Down Expand Up @@ -338,7 +331,7 @@ private TypeID loadFunctionalInterface(TypeVariableContext loadContext, Class<?>
Map<TypeParameter, TypeID> mapping = new HashMap<>();
TypeVariable<?>[] javaParameters = cls.getTypeParameters();
for (int i = 0; i < parameters.length; i++) {
mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i], false));
mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i]));
}

header = header.withGenericArguments(new GenericMapper(mapping, TypeID.NONE));
Expand Down

0 comments on commit 2382bab

Please sign in to comment.