graal-compiler: graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/template/TemplateMethodParser.java comparison

comparison graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/template/TemplateMethodParser.java @ 7679:5f3cba05c2fa

Cleanup and improved error messages.

author	Christian Humer <christian.humer@gmail.com>
date	Thu, 31 Jan 2013 16:21:46 +0100
parents	5e3d1a68664e
children	c17ee8823d72

comparison

equal deleted inserted replaced

-:17b6a63fe7c2
+:5f3cba05c2fa
 MethodSpec methodSpecification = createSpecification(method, annotation);
 if (methodSpecification == null) {
 return null;
 }
+List<TypeDef> typeDefs = createTypeDefinitions(methodSpecification.getReturnType(), methodSpecification.getParameters());
 ParameterSpec returnTypeSpec = methodSpecification.getReturnType();
 List<ParameterSpec> parameterSpecs = new ArrayList<>();
 parameterSpecs.addAll(methodSpecification.getParameters());
 ActualParameter returnTypeMirror = resolveTypeMirror(returnTypeSpec, method.getReturnType(), template);
 if (returnTypeMirror == null) {
 if (isEmitErrors()) {
-String expectedReturnType = createTypeSignature(returnTypeSpec, true);
+String expectedReturnType = createTypeSignature(returnTypeSpec, typeDefs, true);
 String actualReturnType = Utils.getSimpleName(method.getReturnType());
 String message = String.format("The provided return type \"%s\" does not match expected return type \"%s\".\nExpected signature: \n %s", actualReturnType, expectedReturnType,
-createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 context.getLog().error(method, annotation, message);
 }
 return null;
 }
 specification = null;
 continue;
 } else if (!specification.isOptional()) {
 if (isEmitErrors()) {
 // non option type specification found -> argument missing
-String expectedType = createTypeSignature(specification, false);
+String expectedType = createTypeSignature(specification, typeDefs, false);
 String message = String.format("Missing argument \"%s\".\nExpected signature: \n %s", expectedType,
-createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 context.getLog().error(method, message);
 }
 return null;
 } else {
 specification = null;
 continue;
 }
 if (isEmitErrors()) {
-String expectedReturnType = createTypeSignature(specification, false);
+String expectedReturnType = createTypeSignature(specification, typeDefs, false);
 String actualReturnType = Utils.getSimpleName(parameter.asType()) + " " + parameter.getSimpleName();
 String message = String.format("The provided argument type \"%s\" does not match expected type \"%s\".\nExpected signature: \n %s", actualReturnType, expectedReturnType,
-createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 context.getLog().error(parameter, message);
 }
 return null;
 }
 if (variableIterator.hasNext()) {
 parameter = variableIterator.next();
 if (isEmitErrors()) {
 String actualReturnType = Utils.getSimpleName(parameter.asType()) + " " + parameter.getSimpleName();
 String message = String.format("No argument expected but found \"%s\".\nExpected signature: \n %s", actualReturnType,
-createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 context.getLog().error(parameter, message);
 }
 return null;
 }
 return null;
 }
 return new ActualParameter(specification, resolvedType);
 }
-public static String createExpectedSignature(String methodName, ParameterSpec returnType, List<? extends ParameterSpec> parameters) {
+protected static List<TypeDef> createTypeDefinitions(ParameterSpec returnType, List<? extends ParameterSpec> parameters) {
+List<TypeDef> typeDefs = new ArrayList<>();
+TypeMirror[] types = returnType.getAllowedTypes();
+List<ParameterSpec> allParams = new ArrayList<>();
+allParams.add(returnType);
+allParams.addAll(parameters);
+int defIndex = 0;
+for (ParameterSpec spec : allParams) {
+TypeMirror[] allowedTypes = spec.getAllowedTypes();
+if (types != null && allowedTypes.length > 1) {
+TypeDef foundDef = null;
+for (TypeDef def : typeDefs) {
+if (Arrays.equals(spec.getAllowedTypes(), def.getTypes())) {
+foundDef = def;
+break;
+}
+}
+if (foundDef == null) {
+foundDef = new TypeDef(types, "Types" + defIndex);
+typeDefs.add(foundDef);
+defIndex++;
+}
+foundDef.getParameters().add(spec);
+}
+}
+return typeDefs;
+}
+protected static class TypeDef {
+private final TypeMirror[] types;
+private final String name;
+private final List<ParameterSpec> parameters = new ArrayList<>();
+public TypeDef(TypeMirror[] types, String name) {
+this.types = types;
+this.name = name;
+}
+public List<ParameterSpec> getParameters() {
+return parameters;
+}
+public TypeMirror[] getTypes() {
+return types;
+}
+public String getName() {
+return name;
+}
+}
+public static String createExpectedSignature(String methodName, ParameterSpec returnType, List<? extends ParameterSpec> parameters, List<TypeDef> typeDefs) {
 StringBuilder b = new StringBuilder();
 b.append("    ");
-b.append(createTypeSignature(returnType, true));
+b.append(createTypeSignature(returnType, typeDefs, true));
 b.append(" ");
 b.append(methodName);
 b.append("(");
 }
 if (specification.getCardinality() == Cardinality.MULTIPLE) {
 b.append("{");
 }
-b.append(createTypeSignature(specification, false));
+b.append(createTypeSignature(specification, typeDefs, false));
 if (specification.isOptional()) {
 b.append("]");
 }
 }
 b.append(")");
-TypeMirror[] types = null;
+if (!typeDefs.isEmpty()) {
+b.append("\n\n");
-// TODO allowed types may differ so different <Any> must be generated.
-if (returnType.getAllowedTypes().length > 1) {
+String lineSep = "";
-types = returnType.getAllowedTypes();
+for (TypeDef def : typeDefs) {
-}
+b.append(lineSep);
-for (ParameterSpec param : parameters) {
+b.append("    <").append(def.getName()).append(">");
-if (param.getAllowedTypes().length > 1) {
+b.append(" = {");
-types = param.getAllowedTypes();
+String separator = "";
-}
+for (TypeMirror type : def.getTypes()) {
-}
+b.append(separator).append(Utils.getSimpleName(type));
-if (types != null) {
+separator = ", ";
-b.append("\n\n    ");
+}
-b.append("<Any> = {");
+b.append("}");
-String separator = "";
+lineSep = "\n";
-for (TypeMirror type : types) {
-b.append(separator).append(Utils.getSimpleName(type));
+}
-separator = ", ";
-}
-b.append("}");
 }
 return b.toString();
 }
-private static String createTypeSignature(ParameterSpec spec, boolean typeOnly) {
+private static String createTypeSignature(ParameterSpec spec, List<TypeDef> typeDefs, boolean typeOnly) {
 StringBuilder builder = new StringBuilder();
 if (spec.getAllowedTypes().length > 1) {
-builder.append("<Any>");
+TypeDef foundTypeDef = null;
+for (TypeDef typeDef : typeDefs) {
+if (typeDef.getParameters().contains(spec)) {
+foundTypeDef = typeDef;
+break;
+}
+}
+if (foundTypeDef != null) {
+builder.append("<" + foundTypeDef.getName() + ">");
+}
 } else if (spec.getAllowedTypes().length == 1) {
 builder.append(Utils.getSimpleName(spec.getAllowedTypes()[0]));
 } else {
 builder.append("void");
 }

Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/template/TemplateMethodParser.java @ 7679:5f3cba05c2fa