Remove Painless Type From Painless Method/Field (#28466)

jdconrad · jdconrad · commit 89153afcee4e · 2018-01-31T16:44:38.000-08:00
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/Def.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/Def.java
@@ -279,7 +279,7 @@ static MethodHandle lookupMethod(Definition definition, Lookup lookup, MethodTyp
                      captures[capture] = callSiteType.parameterType(i + 1 + capture);
                  }
                  MethodHandle filter;
-                 Definition.Type interfaceType = method.arguments.get(i - 1 - replaced);
+                 Definition.Type interfaceType = definition.ClassToType(method.arguments.get(i - 1 - replaced));
                  if (signature.charAt(0) == 'S') {
                      // the implementation is strongly typed, now that we know the interface type,
                      // we have everything.
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/Definition.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/Definition.java
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ECallLocal.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ECallLocal.java
@@ -69,14 +69,14 @@ void analyze(Locals locals) {
         for (int argument = 0; argument < arguments.size(); ++argument) {
             AExpression expression = arguments.get(argument);
 
-            expression.expected = Definition.TypeToClass(method.arguments.get(argument));
+            expression.expected = method.arguments.get(argument);
             expression.internal = true;
             expression.analyze(locals);
             arguments.set(argument, expression.cast(locals));
         }
 
         statement = true;
-        actual = Definition.TypeToClass(method.rtn);
+        actual = method.rtn;
     }
 
     @Override
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ECapturingFunctionRef.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ECapturingFunctionRef.java
@@ -80,14 +80,13 @@ void analyze(Locals locals) {
 
                     // check casts between the interface method and the delegate method are legal
                     for (int i = 0; i < ref.interfaceMethod.arguments.size(); ++i) {
-                        Class<?> from = Definition.TypeToClass(ref.interfaceMethod.arguments.get(i));
-                        Class<?> to = Definition.TypeToClass(ref.delegateMethod.arguments.get(i));
+                        Class<?> from = ref.interfaceMethod.arguments.get(i);
+                        Class<?> to = ref.delegateMethod.arguments.get(i);
                         AnalyzerCaster.getLegalCast(location, from, to, false, true);
                     }
 
-                    if (ref.interfaceMethod.rtn.clazz != void.class) {
-                        AnalyzerCaster.getLegalCast(location,
-                            Definition.TypeToClass(ref.delegateMethod.rtn), Definition.TypeToClass(ref.interfaceMethod.rtn), false, true);
+                    if (ref.interfaceMethod.rtn != void.class) {
+                        AnalyzerCaster.getLegalCast(location, ref.delegateMethod.rtn, ref.interfaceMethod.rtn, false, true);
                     }
                 } catch (IllegalArgumentException e) {
                     throw createError(e);
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/EFunctionRef.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/EFunctionRef.java
@@ -80,14 +80,13 @@ void analyze(Locals locals) {
 
                     // check casts between the interface method and the delegate method are legal
                     for (int i = 0; i < interfaceMethod.arguments.size(); ++i) {
-                        Class<?> from = Definition.TypeToClass(interfaceMethod.arguments.get(i));
-                        Class<?> to = Definition.TypeToClass(delegateMethod.arguments.get(i));
+                        Class<?> from = interfaceMethod.arguments.get(i);
+                        Class<?> to = delegateMethod.arguments.get(i);
                         AnalyzerCaster.getLegalCast(location, from, to, false, true);
                     }
 
-                    if (interfaceMethod.rtn.clazz != void.class) {
-                        AnalyzerCaster.getLegalCast(
-                            location, Definition.TypeToClass(delegateMethod.rtn), Definition.TypeToClass(interfaceMethod.rtn), false, true);
+                    if (interfaceMethod.rtn != void.class) {
+                        AnalyzerCaster.getLegalCast(location, delegateMethod.rtn, interfaceMethod.rtn, false, true);
                     }
                 } else {
                     // whitelist lookup
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ELambda.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ELambda.java
@@ -130,17 +130,17 @@ void analyze(Locals locals) {
                 throw new IllegalArgumentException("Incorrect number of parameters for [" + interfaceMethod.name +
                                                    "] in [" + Definition.ClassToName(expected) + "]");
             // for method invocation, its allowed to ignore the return value
-            if (interfaceMethod.rtn.equals(locals.getDefinition().voidType)) {
+            if (interfaceMethod.rtn == void.class) {
                 returnType = def.class;
             } else {
-                returnType = Definition.TypeToClass(interfaceMethod.rtn);
+                returnType = interfaceMethod.rtn;
             }
             // replace any null types with the actual type
             actualParamTypeStrs = new ArrayList<>(paramTypeStrs.size());
             for (int i = 0; i < paramTypeStrs.size(); i++) {
                 String paramType = paramTypeStrs.get(i);
                 if (paramType == null) {
-                    actualParamTypeStrs.add(interfaceMethod.arguments.get(i).name);
+                    actualParamTypeStrs.add(Definition.ClassToName(interfaceMethod.arguments.get(i)));
                 } else {
                     actualParamTypeStrs.add(paramType);
                 }
@@ -190,14 +190,13 @@ void analyze(Locals locals) {
 
             // check casts between the interface method and the delegate method are legal
             for (int i = 0; i < interfaceMethod.arguments.size(); ++i) {
-                Class<?> from = Definition.TypeToClass(interfaceMethod.arguments.get(i));
+                Class<?> from = interfaceMethod.arguments.get(i);
                 Class<?> to = Definition.TypeToClass(desugared.parameters.get(i + captures.size()).type);
                 AnalyzerCaster.getLegalCast(location, from, to, false, true);
             }
 
-            if (interfaceMethod.rtn.clazz != void.class) {
-                AnalyzerCaster.getLegalCast(
-                    location, Definition.TypeToClass(desugared.rtnType), Definition.TypeToClass(interfaceMethod.rtn), false, true);
+            if (interfaceMethod.rtn != void.class) {
+                AnalyzerCaster.getLegalCast(location, desugared.rtnType, interfaceMethod.rtn, false, true);
             }
 
             actual = expected;
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ENewObj.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/ENewObj.java
@@ -68,7 +68,7 @@ void analyze(Locals locals) {
         constructor = struct.constructors.get(new Definition.MethodKey("<init>", arguments.size()));
 
         if (constructor != null) {
-            Type[] types = new Type[constructor.arguments.size()];
+            Class<?>[] types = new Class<?>[constructor.arguments.size()];
             constructor.arguments.toArray(types);
 
             if (constructor.arguments.size() != arguments.size()) {
@@ -79,7 +79,7 @@ void analyze(Locals locals) {
             for (int argument = 0; argument < arguments.size(); ++argument) {
                 AExpression expression = arguments.get(argument);
 
-                expression.expected = Definition.TypeToClass(types[argument]);
+                expression.expected = types[argument];
                 expression.internal = true;
                 expression.analyze(locals);
                 arguments.set(argument, expression.cast(locals));
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubCallInvoke.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubCallInvoke.java
@@ -57,14 +57,14 @@ void analyze(Locals locals) {
         for (int argument = 0; argument < arguments.size(); ++argument) {
             AExpression expression = arguments.get(argument);
 
-            expression.expected = Definition.TypeToClass(method.arguments.get(argument));
+            expression.expected = method.arguments.get(argument);
             expression.internal = true;
             expression.analyze(locals);
             arguments.set(argument, expression.cast(locals));
         }
 
         statement = true;
-        actual = Definition.TypeToClass(method.rtn);
+        actual = method.rtn;
     }
 
     @Override
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubField.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubField.java
@@ -52,20 +52,20 @@ void extractVariables(Set<String> variables) {
     void analyze(Locals locals) {
          if (write && Modifier.isFinal(field.modifiers)) {
              throw createError(new IllegalArgumentException(
-                 "Cannot write to read-only field [" + field.name + "] for type [" + field.type.name + "]."));
+                 "Cannot write to read-only field [" + field.name + "] for type [" + Definition.ClassToName(field.clazz) + "]."));
          }
 
-        actual = Definition.TypeToClass(field.type);
+        actual = field.clazz;
     }
 
     @Override
     void write(MethodWriter writer, Globals globals) {
         writer.writeDebugInfo(location);
 
         if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {
-            writer.getStatic(field.owner.type, field.javaName, field.type.type);
+            writer.getStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         } else {
-            writer.getField(field.owner.type, field.javaName, field.type.type);
+            writer.getField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         }
     }
 
@@ -94,9 +94,9 @@ void load(MethodWriter writer, Globals globals) {
         writer.writeDebugInfo(location);
 
         if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {
-            writer.getStatic(field.owner.type, field.javaName, field.type.type);
+            writer.getStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         } else {
-            writer.getField(field.owner.type, field.javaName, field.type.type);
+            writer.getField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         }
     }
 
@@ -105,9 +105,9 @@ void store(MethodWriter writer, Globals globals) {
         writer.writeDebugInfo(location);
 
         if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {
-            writer.putStatic(field.owner.type, field.javaName, field.type.type);
+            writer.putStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         } else {
-            writer.putField(field.owner.type, field.javaName, field.type.type);
+            writer.putField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));
         }
     }
 
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubListShortcut.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubListShortcut.java
@@ -59,12 +59,12 @@ void analyze(Locals locals) {
         getter = struct.methods.get(new Definition.MethodKey("get", 1));
         setter = struct.methods.get(new Definition.MethodKey("set", 2));
 
-        if (getter != null && (getter.rtn.clazz == void.class || getter.arguments.size() != 1 ||
-            getter.arguments.get(0).clazz != int.class)) {
+        if (getter != null && (getter.rtn == void.class || getter.arguments.size() != 1 ||
+            getter.arguments.get(0) != int.class)) {
             throw createError(new IllegalArgumentException("Illegal list get shortcut for type [" + struct.name + "]."));
         }
 
-        if (setter != null && (setter.arguments.size() != 2 || setter.arguments.get(0).clazz != int.class)) {
+        if (setter != null && (setter.arguments.size() != 2 || setter.arguments.get(0) != int.class)) {
             throw createError(new IllegalArgumentException("Illegal list set shortcut for type [" + struct.name + "]."));
         }
 
@@ -78,7 +78,7 @@ void analyze(Locals locals) {
             index.analyze(locals);
             index = index.cast(locals);
 
-            actual = setter != null ? Definition.TypeToClass(setter.arguments.get(1)) : Definition.TypeToClass(getter.rtn);
+            actual = setter != null ? setter.arguments.get(1) : getter.rtn;
         } else {
             throw createError(new IllegalArgumentException("Illegal list shortcut for type [" + struct.name + "]."));
         }
@@ -119,8 +119,8 @@ void load(MethodWriter writer, Globals globals) {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn == getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -130,7 +130,7 @@ void store(MethodWriter writer, Globals globals) {
 
         setter.write(writer);
 
-        writer.writePop(setter.rtn.type.getSize());
+        writer.writePop(MethodWriter.getType(setter.rtn).getSize());
     }
 
     @Override
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubMapShortcut.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubMapShortcut.java
@@ -58,7 +58,7 @@ void analyze(Locals locals) {
         getter = struct.methods.get(new Definition.MethodKey("get", 1));
         setter = struct.methods.get(new Definition.MethodKey("put", 2));
 
-        if (getter != null && (getter.rtn.clazz == void.class || getter.arguments.size() != 1)) {
+        if (getter != null && (getter.rtn == void.class || getter.arguments.size() != 1)) {
             throw createError(new IllegalArgumentException("Illegal map get shortcut for type [" + struct.name + "]."));
         }
 
@@ -72,12 +72,11 @@ void analyze(Locals locals) {
         }
 
         if ((read || write) && (!read || getter != null) && (!write || setter != null)) {
-            index.expected = setter != null ?
-                    Definition.TypeToClass(setter.arguments.get(0)) : Definition.TypeToClass(getter.arguments.get(0));
+            index.expected = setter != null ? setter.arguments.get(0) : getter.arguments.get(0);
             index.analyze(locals);
             index = index.cast(locals);
 
-            actual = setter != null ? Definition.TypeToClass(setter.arguments.get(1)) : Definition.TypeToClass(getter.rtn);
+            actual = setter != null ? setter.arguments.get(1) : getter.rtn;
         } else {
             throw createError(new IllegalArgumentException("Illegal map shortcut for type [" + struct.name + "]."));
         }
@@ -91,8 +90,8 @@ void write(MethodWriter writer, Globals globals) {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn != getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -122,8 +121,8 @@ void load(MethodWriter writer, Globals globals) {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn != getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -133,7 +132,7 @@ void store(MethodWriter writer, Globals globals) {
 
         setter.write(writer);
 
-        writer.writePop(setter.rtn.type.getSize());
+        writer.writePop(MethodWriter.getType(setter.rtn).getSize());
     }
 
     @Override
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubShortcut.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/PSubShortcut.java
@@ -54,12 +54,12 @@ void extractVariables(Set<String> variables) {
 
     @Override
     void analyze(Locals locals) {
-        if (getter != null && (getter.rtn.clazz == void.class || !getter.arguments.isEmpty())) {
+        if (getter != null && (getter.rtn == void.class || !getter.arguments.isEmpty())) {
             throw createError(new IllegalArgumentException(
                 "Illegal get shortcut on field [" + value + "] for type [" + type + "]."));
         }
 
-        if (setter != null && (setter.rtn.clazz != void.class || setter.arguments.size() != 1)) {
+        if (setter != null && (setter.rtn != void.class || setter.arguments.size() != 1)) {
             throw createError(new IllegalArgumentException(
                 "Illegal set shortcut on field [" + value + "] for type [" + type + "]."));
         }
@@ -69,7 +69,7 @@ void analyze(Locals locals) {
         }
 
         if ((getter != null || setter != null) && (!read || getter != null) && (!write || setter != null)) {
-            actual = setter != null ? Definition.TypeToClass(setter.arguments.get(0)) : Definition.TypeToClass(getter.rtn);
+            actual = setter != null ? setter.arguments.get(0) : getter.rtn;
         } else {
             throw createError(new IllegalArgumentException("Illegal shortcut on field [" + value + "] for type [" + type + "]."));
         }
@@ -81,8 +81,8 @@ void write(MethodWriter writer, Globals globals) {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (!getter.rtn.equals(getter.handle.type().returnType())) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -112,8 +112,8 @@ void load(MethodWriter writer, Globals globals) {
 
         getter.write(writer);
 
-        if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {
-            writer.checkCast(getter.rtn.type);
+        if (getter.rtn != getter.handle.type().returnType()) {
+            writer.checkCast(MethodWriter.getType(getter.rtn));
         }
     }
 
@@ -123,7 +123,7 @@ void store(MethodWriter writer, Globals globals) {
 
         setter.write(writer);
 
-        writer.writePop(setter.rtn.type.getSize());
+        writer.writePop(MethodWriter.getType(setter.rtn).getSize());
     }
 
     @Override
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/SFunction.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/SFunction.java
diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/SSource.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/node/SSource.java
diff --git a/modules/lang-painless/src/test/java/org/elasticsearch/painless/PainlessDocGenerator.java b/modules/lang-painless/src/test/java/org/elasticsearch/painless/PainlessDocGenerator.java

Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ static MethodHandle lookupMethod(Definition definition, Lookup lookup, MethodTyp`
`279`	`279`	`captures[capture] = callSiteType.parameterType(i + 1 + capture);`
`280`	`280`	`}`
`281`	`281`	`MethodHandle filter;`
`282`		`- Definition.Type interfaceType = method.arguments.get(i - 1 - replaced);`
	`282`	`+ Definition.Type interfaceType = definition.ClassToType(method.arguments.get(i - 1 - replaced));`
`283`	`283`	`if (signature.charAt(0) == 'S') {`
`284`	`284`	`// the implementation is strongly typed, now that we know the interface type,`
`285`	`285`	`// we have everything.`
Original file line number	Diff line number	Diff line change
`@@ -69,14 +69,14 @@ void analyze(Locals locals) {`
`69`	`69`	`for (int argument = 0; argument < arguments.size(); ++argument) {`
`70`	`70`	`AExpression expression = arguments.get(argument);`
`71`	`71`
`72`		`- expression.expected = Definition.TypeToClass(method.arguments.get(argument));`
	`72`	`+ expression.expected = method.arguments.get(argument);`
`73`	`73`	`expression.internal = true;`
`74`	`74`	`expression.analyze(locals);`
`75`	`75`	`arguments.set(argument, expression.cast(locals));`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`statement = true;`
`79`		`- actual = Definition.TypeToClass(method.rtn);`
	`79`	`+ actual = method.rtn;`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -57,14 +57,14 @@ void analyze(Locals locals) {`
`57`	`57`	`for (int argument = 0; argument < arguments.size(); ++argument) {`
`58`	`58`	`AExpression expression = arguments.get(argument);`
`59`	`59`
`60`		`- expression.expected = Definition.TypeToClass(method.arguments.get(argument));`
	`60`	`+ expression.expected = method.arguments.get(argument);`
`61`	`61`	`expression.internal = true;`
`62`	`62`	`expression.analyze(locals);`
`63`	`63`	`arguments.set(argument, expression.cast(locals));`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`statement = true;`
`67`		`- actual = Definition.TypeToClass(method.rtn);`
	`67`	`+ actual = method.rtn;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -52,20 +52,20 @@ void extractVariables(Set<String> variables) {`
`52`	`52`	`void analyze(Locals locals) {`
`53`	`53`	`if (write && Modifier.isFinal(field.modifiers)) {`
`54`	`54`	`throw createError(new IllegalArgumentException(`
`55`		`- "Cannot write to read-only field [" + field.name + "] for type [" + field.type.name + "]."));`
	`55`	`+ "Cannot write to read-only field [" + field.name + "] for type [" + Definition.ClassToName(field.clazz) + "]."));`
`56`	`56`	`}`
`57`	`57`
`58`		`- actual = Definition.TypeToClass(field.type);`
	`58`	`+ actual = field.clazz;`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`@Override`
`62`	`62`	`void write(MethodWriter writer, Globals globals) {`
`63`	`63`	`writer.writeDebugInfo(location);`
`64`	`64`
`65`	`65`	`if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {`
`66`		`- writer.getStatic(field.owner.type, field.javaName, field.type.type);`
	`66`	`+ writer.getStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));`
`67`	`67`	`} else {`
`68`		`- writer.getField(field.owner.type, field.javaName, field.type.type);`
	`68`	`+ writer.getField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`@@ -94,9 +94,9 @@ void load(MethodWriter writer, Globals globals) {`
`94`	`94`	`writer.writeDebugInfo(location);`
`95`	`95`
`96`	`96`	`if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {`
`97`		`- writer.getStatic(field.owner.type, field.javaName, field.type.type);`
	`97`	`+ writer.getStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));`
`98`	`98`	`} else {`
`99`		`- writer.getField(field.owner.type, field.javaName, field.type.type);`
	`99`	`+ writer.getField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`@@ -105,9 +105,9 @@ void store(MethodWriter writer, Globals globals) {`
`105`	`105`	`writer.writeDebugInfo(location);`
`106`	`106`
`107`	`107`	`if (java.lang.reflect.Modifier.isStatic(field.modifiers)) {`
`108`		`- writer.putStatic(field.owner.type, field.javaName, field.type.type);`
	`108`	`+ writer.putStatic(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));`
`109`	`109`	`} else {`
`110`		`- writer.putField(field.owner.type, field.javaName, field.type.type);`
	`110`	`+ writer.putField(field.owner.type, field.javaName, MethodWriter.getType(field.clazz));`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
Original file line number	Diff line number	Diff line change
`@@ -59,12 +59,12 @@ void analyze(Locals locals) {`
`59`	`59`	`getter = struct.methods.get(new Definition.MethodKey("get", 1));`
`60`	`60`	`setter = struct.methods.get(new Definition.MethodKey("set", 2));`
`61`	`61`
`62`		`- if (getter != null && (getter.rtn.clazz == void.class \|\| getter.arguments.size() != 1 \|\|`
`63`		`- getter.arguments.get(0).clazz != int.class)) {`
	`62`	`+ if (getter != null && (getter.rtn == void.class \|\| getter.arguments.size() != 1 \|\|`
	`63`	`+ getter.arguments.get(0) != int.class)) {`
`64`	`64`	`throw createError(new IllegalArgumentException("Illegal list get shortcut for type [" + struct.name + "]."));`
`65`	`65`	`}`
`66`	`66`
`67`		`- if (setter != null && (setter.arguments.size() != 2 \|\| setter.arguments.get(0).clazz != int.class)) {`
	`67`	`+ if (setter != null && (setter.arguments.size() != 2 \|\| setter.arguments.get(0) != int.class)) {`
`68`	`68`	`throw createError(new IllegalArgumentException("Illegal list set shortcut for type [" + struct.name + "]."));`
`69`	`69`	`}`
`70`	`70`
`@@ -78,7 +78,7 @@ void analyze(Locals locals) {`
`78`	`78`	`index.analyze(locals);`
`79`	`79`	`index = index.cast(locals);`
`80`	`80`
`81`		`- actual = setter != null ? Definition.TypeToClass(setter.arguments.get(1)) : Definition.TypeToClass(getter.rtn);`
	`81`	`+ actual = setter != null ? setter.arguments.get(1) : getter.rtn;`
`82`	`82`	`} else {`
`83`	`83`	`throw createError(new IllegalArgumentException("Illegal list shortcut for type [" + struct.name + "]."));`
`84`	`84`	`}`
`@@ -119,8 +119,8 @@ void load(MethodWriter writer, Globals globals) {`
`119`	`119`
`120`	`120`	`getter.write(writer);`
`121`	`121`
`122`		`- if (!getter.rtn.clazz.equals(getter.handle.type().returnType())) {`
`123`		`- writer.checkCast(getter.rtn.type);`
	`122`	`+ if (getter.rtn == getter.handle.type().returnType()) {`
	`123`	`+ writer.checkCast(MethodWriter.getType(getter.rtn));`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`@@ -130,7 +130,7 @@ void store(MethodWriter writer, Globals globals) {`
`130`	`130`
`131`	`131`	`setter.write(writer);`
`132`	`132`
`133`		`- writer.writePop(setter.rtn.type.getSize());`
	`133`	`+ writer.writePop(MethodWriter.getType(setter.rtn).getSize());`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`@Override`