Skip to content

Commit 417e99a

Browse files
stanhebbenstanhebben
committed
WIP removing stored types
1 parent 4d53b6c commit 417e99a

File tree

181 files changed

+1388
-2092
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

181 files changed

+1388
-2092
lines changed

‎CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,6 @@
7070
import org.openzen.zenscript.codemodel.expression.SetterExpression;
7171
import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
7272
import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
73-
import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
7473
import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
7574
import org.openzen.zenscript.codemodel.expression.ThisExpression;
7675
import org.openzen.zenscript.codemodel.expression.ThrowExpression;

‎CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FormattingUtils.java‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@
3030
import org.openzen.zenscript.codemodel.statement.VarStatement;
3131
import org.openzen.zenscript.codemodel.statement.WhileStatement;
3232
import org.openzen.zenscript.codemodel.type.BasicTypeID;
33-
import org.openzen.zenscript.codemodel.type.StoredType;
33+
import org.openzen.zenscript.codemodel.type.TypeID;
3434

3535
/**
3636
*
@@ -78,15 +78,15 @@ public static void formatHeader(StringBuilder result, ScriptFormattingSettings s
7878
if (parameter.variadic)
7979
result.append("...");
8080

81-
if (!settings.showAnyInFunctionHeaders || !parameter.type.isBasic(BasicTypeID.UNDETERMINED)) {
81+
if (!settings.showAnyInFunctionHeaders || parameter.type != BasicTypeID.UNDETERMINED) {
8282
result.append(" as ");
8383
result.append(typeFormatter.format(header.getReturnType()));
8484
}
8585

8686
parameterIndex++;
8787
}
8888
result.append(")");
89-
if (!settings.showAnyInFunctionHeaders || !header.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
89+
if (!settings.showAnyInFunctionHeaders || header.getReturnType() != BasicTypeID.UNDETERMINED) {
9090
result.append(" as ");
9191
result.append(typeFormatter.format(header.getReturnType()));
9292
}
@@ -128,7 +128,7 @@ public static void formatCall(StringBuilder result, TypeFormatter typeFormatter,
128128
result.append("<");
129129

130130
int index = 0;
131-
for (StoredType typeArgument : arguments.typeArguments) {
131+
for (TypeID typeArgument : arguments.typeArguments) {
132132
if (index > 0)
133133
result.append(", ");
134134
result.append(typeFormatter.format(typeArgument));

‎CodeFormatter/src/main/java/org/openzen/zenscript/formatter/TypeFormatter.java‎

Lines changed: 1 addition & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,6 @@
2121
import org.openzen.zenscript.codemodel.type.IteratorTypeID;
2222
import org.openzen.zenscript.codemodel.type.RangeTypeID;
2323
import org.openzen.zenscript.codemodel.type.StoredType;
24-
import org.openzen.zenscript.codemodel.type.StringTypeID;
2524
import org.openzen.zenscript.codemodel.type.TypeID;
2625
import stdlib.Chars;
2726
import org.openzen.zenscript.codemodel.type.TypeVisitor;
@@ -51,11 +50,6 @@ public String format(StoredType type) {
5150
public String visitBasic(BasicTypeID basic) {
5251
return basic.name;
5352
}
54-
55-
@Override
56-
public String visitString(StringTypeID string) {
57-
return "string";
58-
}
5953

6054
@Override
6155
public String visitArray(ArrayTypeID array) {
@@ -97,7 +91,7 @@ public String visitDefinition(DefinitionTypeID definition) {
9791
result.append(importedName);
9892
result.append("<");
9993
int index = 0;
100-
for (StoredType typeParameter : definition.typeArguments) {
94+
for (TypeID typeParameter : definition.typeArguments) {
10195
if (index > 0)
10296
result.append(", ");
10397

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

Lines changed: 40 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -14,53 +14,44 @@
1414
import org.openzen.zenscript.codemodel.type.BasicTypeID;
1515
import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
1616
import org.openzen.zenscript.codemodel.scope.TypeScope;
17-
import org.openzen.zenscript.codemodel.type.StoredType;
18-
import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
19-
import org.openzen.zenscript.codemodel.type.storage.StorageTag;
17+
import org.openzen.zenscript.codemodel.type.TypeID;
2018

2119
/**
2220
*
2321
* @author Hoofdgebruiker
2422
*/
2523
public class FunctionHeader {
2624
public final TypeParameter[] typeParameters;
27-
private StoredType returnType;
25+
private TypeID returnType;
2826
public final FunctionParameter[] parameters;
29-
public final StoredType thrownType;
30-
public final StorageTag storage;
31-
27+
public final TypeID thrownType;
28+
3229
public final int minParameters;
3330
public final int maxParameters;
3431
public final boolean hasUnknowns;
3532

36-
public FunctionHeader(StoredType returnType) {
33+
public FunctionHeader(TypeID returnType) {
3734
if (returnType == null)
3835
throw new NullPointerException();
3936

4037
this.typeParameters = TypeParameter.NONE;
4138
this.returnType = returnType;
4239
this.parameters = FunctionParameter.NONE;
4340
this.thrownType = null;
44-
this.storage = null;
4541

4642
minParameters = 0;
4743
maxParameters = 0;
48-
hasUnknowns = returnType.type == BasicTypeID.UNDETERMINED;
49-
}
50-
51-
public FunctionHeader(BasicTypeID returnType) {
52-
this(returnType.stored);
44+
hasUnknowns = returnType == BasicTypeID.UNDETERMINED;
5345
}
5446

55-
public FunctionHeader(StoredType returnType, StoredType... parameterTypes) {
47+
public FunctionHeader(TypeID returnType, TypeID... parameterTypes) {
5648
if (returnType == null)
5749
throw new NullPointerException();
5850

5951
this.typeParameters = TypeParameter.NONE;
6052
this.returnType = returnType;
6153
this.parameters = new FunctionParameter[parameterTypes.length];
6254
this.thrownType = null;
63-
this.storage = null;
6455

6556
for (int i = 0; i < parameterTypes.length; i++)
6657
parameters[i] = new FunctionParameter(parameterTypes[i], null);
@@ -70,30 +61,21 @@ public FunctionHeader(StoredType returnType, StoredType... parameterTypes) {
7061
hasUnknowns = hasUnknowns(parameterTypes, returnType);
7162
}
7263

73-
public FunctionHeader(BasicTypeID returnType, StoredType... parameterTypes) {
74-
this(returnType.stored, parameterTypes);
75-
}
76-
77-
public FunctionHeader(StoredType returnType, FunctionParameter... parameters) {
64+
public FunctionHeader(TypeID returnType, FunctionParameter... parameters) {
7865
if (returnType == null)
7966
throw new NullPointerException();
8067

8168
this.typeParameters = TypeParameter.NONE;
8269
this.returnType = returnType;
8370
this.parameters = parameters;
8471
this.thrownType = null;
85-
this.storage = null;
8672

8773
minParameters = getMinParameters(parameters);
8874
maxParameters = getMaxParameters(parameters);
8975
hasUnknowns = hasUnknowns(parameters, returnType);
9076
}
9177

92-
public FunctionHeader(BasicTypeID returnType, FunctionParameter... parameters) {
93-
this(returnType.stored, parameters);
94-
}
95-
96-
public FunctionHeader(TypeParameter[] typeParameters, StoredType returnType, StoredType thrownType, StorageTag storage, FunctionParameter... parameters) {
78+
public FunctionHeader(TypeParameter[] typeParameters, TypeID returnType, TypeID thrownType, FunctionParameter... parameters) {
9779
if (returnType == null)
9880
throw new NullPointerException();
9981
if (typeParameters == null)
@@ -103,7 +85,6 @@ public FunctionHeader(TypeParameter[] typeParameters, StoredType returnType, Sto
10385
this.returnType = returnType;
10486
this.parameters = parameters;
10587
this.thrownType = thrownType;
106-
this.storage = storage;
10788

10889
minParameters = getMinParameters(parameters);
10990
maxParameters = getMaxParameters(parameters);
@@ -148,18 +129,18 @@ public boolean[] useTypeParameters() {
148129
return useTypeParameters;
149130
}
150131

151-
public StoredType getReturnType() {
132+
public TypeID getReturnType() {
152133
return returnType;
153134
}
154135

155-
public void setReturnType(StoredType returnType) {
136+
public void setReturnType(TypeID returnType) {
156137
if (returnType == null)
157138
throw new NullPointerException();
158139

159140
this.returnType = returnType;
160141
}
161142

162-
public StoredType getParameterType(boolean isVariadic, int index) {
143+
public TypeID getParameterType(boolean isVariadic, int index) {
163144
return getParameter(isVariadic, index).type;
164145
}
165146

@@ -188,7 +169,7 @@ public FunctionHeader normalize(GlobalTypeRegistry registry) {
188169
FunctionParameter[] normalizedParameters = new FunctionParameter[parameters.length];
189170
for (int i = 0; i < normalizedParameters.length; i++)
190171
normalizedParameters[i] = parameters[i].normalize(registry);
191-
return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), storage, normalizedParameters);
172+
return new FunctionHeader(typeParameters, returnType.getNormalized(), thrownType == null ? null : thrownType.getNormalized(), normalizedParameters);
192173
}
193174

194175
public int getNumberOfTypeParameters() {
@@ -205,28 +186,24 @@ public boolean hasAnyDefaultValues() {
205186

206187
public FunctionHeader inferFromOverride(GlobalTypeRegistry registry, FunctionHeader overridden) {
207188
TypeParameter[] resultTypeParameters = typeParameters;
208-
StoredType resultReturnType = this.returnType;
209-
if (resultReturnType.type == BasicTypeID.UNDETERMINED)
189+
TypeID resultReturnType = this.returnType;
190+
if (resultReturnType == BasicTypeID.UNDETERMINED)
210191
resultReturnType = overridden.returnType;
211-
212-
StoredType resultThrownType = this.thrownType;
192+
193+
TypeID resultThrownType = this.thrownType;
213194
if (resultThrownType == null && overridden.thrownType != null)
214195
resultThrownType = overridden.thrownType;
215196

216197
FunctionParameter[] resultParameters = Arrays.copyOf(parameters, parameters.length);
217198
for (int i = 0; i < resultParameters.length; i++) {
218-
if (resultParameters[i].type.type == BasicTypeID.UNDETERMINED) {
199+
if (resultParameters[i].type == BasicTypeID.UNDETERMINED) {
219200
FunctionParameter parameter = resultParameters[i];
220201
FunctionParameter original = overridden.parameters[i];
221202
resultParameters[i] = new FunctionParameter(original.type, parameter.name, parameter.defaultValue, original.variadic);
222203
}
223204
}
224205

225-
StorageTag resultStorage = this.storage;
226-
if (resultStorage == null)
227-
resultStorage = overridden.storage;
228-
229-
return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultStorage, resultParameters);
206+
return new FunctionHeader(resultTypeParameters, resultReturnType, resultThrownType, resultParameters);
230207
}
231208

232209
public boolean matchesExactly(CodePosition position, CallArguments arguments, TypeScope scope) {
@@ -266,8 +243,6 @@ public String getCanonicalWithoutReturnType() {
266243
}
267244
result.append('>');
268245
}
269-
if (storage != null && storage != AutoStorageTag.INSTANCE)
270-
result.append('`').append(storage);
271246
result.append('(');
272247
for (int i = 0; i < parameters.length; i++) {
273248
if (i > 0)
@@ -279,7 +254,7 @@ public String getCanonicalWithoutReturnType() {
279254
}
280255

281256
public String getCanonical() {
282-
return getCanonicalWithoutReturnType() + returnType.type.toString();
257+
return getCanonicalWithoutReturnType() + returnType.toString();
283258
}
284259

285260
public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
@@ -307,11 +282,11 @@ public boolean canOverride(TypeScope scope, FunctionHeader other) {
307282
throw new NullPointerException();
308283
if (parameters.length != other.parameters.length)
309284
return false;
310-
if (returnType.type != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))
285+
if (returnType != BasicTypeID.UNDETERMINED && !scope.getTypeMembers(returnType).canCastImplicit(other.returnType))
311286
return false;
312287

313288
for (int i = 0; i < parameters.length; i++) {
314-
if (parameters[i].type.type == BasicTypeID.UNDETERMINED)
289+
if (parameters[i].type == BasicTypeID.UNDETERMINED)
315290
continue;
316291

317292
if (parameters[i].variadic != other.parameters[i].variadic)
@@ -376,7 +351,7 @@ public boolean isSimilarTo(FunctionHeader other) {
376351

377352
public FunctionHeader instanceForCall(CodePosition position, GlobalTypeRegistry registry, CallArguments arguments) {
378353
if (arguments.getNumberOfTypeArguments() > 0) {
379-
Map<TypeParameter, StoredType> typeParameters = StoredType.getMapping(this.typeParameters, arguments.typeArguments);
354+
Map<TypeParameter, TypeID> typeParameters = TypeID.getMapping(this.typeParameters, arguments.typeArguments);
380355
return instance(new GenericMapper(position, registry, typeParameters));
381356
} else {
382357
return this;
@@ -385,45 +360,45 @@ public FunctionHeader instanceForCall(CodePosition position, GlobalTypeRegistry
385360

386361
public FunctionHeader withGenericArguments(GenericMapper mapper) {
387362
if (typeParameters.length > 0)
388-
mapper = mapper.getInner(mapper.position, mapper.registry, StoredType.getSelfMapping(mapper.registry, typeParameters));
363+
mapper = mapper.getInner(mapper.position, mapper.registry, TypeID.getSelfMapping(mapper.registry, typeParameters));
389364

390365
return instance(mapper);
391366
}
392367

393368
private FunctionHeader instance(GenericMapper mapper) {
394-
StoredType returnType = this.returnType.instance(mapper);
369+
TypeID returnType = this.returnType.instance(mapper);
395370
FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
396371
for (int i = 0; i < parameters.length; i++) {
397372
parameters[i] = this.parameters[i].withGenericArguments(mapper);
398373
}
399-
return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
374+
return new FunctionHeader(typeParameters, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
400375
}
401376

402-
public FunctionHeader fillGenericArguments(CodePosition position, TypeScope scope, StoredType[] arguments) {
377+
public FunctionHeader fillGenericArguments(CodePosition position, TypeScope scope, TypeID[] arguments) {
403378
if (arguments == null || arguments.length == 0)
404379
return this;
405380

406-
Map<TypeParameter, StoredType> typeArguments = StoredType.getMapping(typeParameters, arguments);
381+
Map<TypeParameter, TypeID> typeArguments = TypeID.getMapping(typeParameters, arguments);
407382
GenericMapper mapper = scope.getLocalTypeParameters().getInner(position, scope.getTypeRegistry(), typeArguments);
408-
409-
StoredType returnType = this.returnType.instance(mapper);
383+
384+
TypeID returnType = this.returnType.instance(mapper);
410385
FunctionParameter[] parameters = new FunctionParameter[this.parameters.length];
411386
for (int i = 0; i < parameters.length; i++) {
412387
parameters[i] = this.parameters[i].withGenericArguments(mapper);
413388
}
414-
return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), storage, parameters);
389+
return new FunctionHeader(TypeParameter.NONE, returnType, thrownType == null ? null : thrownType.instance(mapper), parameters);
415390
}
416391

417392
public FunctionHeader forTypeParameterInference() {
418-
return new FunctionHeader(BasicTypeID.UNDETERMINED.stored, parameters);
393+
return new FunctionHeader(BasicTypeID.UNDETERMINED, parameters);
419394
}
420395

421396
public FunctionHeader forLambda(FunctionHeader lambdaHeader) {
422397
FunctionParameter[] parameters = new FunctionParameter[lambdaHeader.parameters.length];
423398
for (int i = 0; i < lambdaHeader.parameters.length; i++)
424399
parameters[i] = new FunctionParameter(this.parameters[i].type, lambdaHeader.parameters[i].name);
425400

426-
return new FunctionHeader(typeParameters, returnType, thrownType, storage, parameters);
401+
return new FunctionHeader(typeParameters, returnType, thrownType, parameters);
427402
}
428403

429404
public FunctionParameter getVariadicParameter() {
@@ -489,23 +464,23 @@ private static int getMaxParameters(FunctionParameter[] parameters) {
489464
return parameters[parameters.length - 1].variadic ? Integer.MAX_VALUE : parameters.length;
490465
}
491466

492-
private static boolean hasUnknowns(StoredType[] types, StoredType returnType) {
493-
if (returnType.type == BasicTypeID.UNDETERMINED)
467+
private static boolean hasUnknowns(TypeID[] types, TypeID returnType) {
468+
if (returnType == BasicTypeID.UNDETERMINED)
494469
return true;
495470

496-
for (StoredType type : types)
497-
if (type.type == BasicTypeID.UNDETERMINED)
471+
for (TypeID type : types)
472+
if (type == BasicTypeID.UNDETERMINED)
498473
return true;
499474

500475
return false;
501476
}
502477

503-
private static boolean hasUnknowns(FunctionParameter[] parameters, StoredType returnType) {
504-
if (returnType.type == BasicTypeID.UNDETERMINED)
478+
private static boolean hasUnknowns(FunctionParameter[] parameters, TypeID returnType) {
479+
if (returnType == BasicTypeID.UNDETERMINED)
505480
return true;
506481

507482
for (FunctionParameter parameter : parameters)
508-
if (parameter.type.type == BasicTypeID.UNDETERMINED)
483+
if (parameter.type == BasicTypeID.UNDETERMINED)
509484
return true;
510485

511486
return false;

0 commit comments

Comments
 (0)