| /* |
| * Copyright 2009 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.dev.javac; |
| |
| import com.google.gwt.core.client.impl.ArtificialRescue; |
| import com.google.gwt.dev.jdt.SafeASTVisitor; |
| import com.google.gwt.dev.jjs.InternalCompilerException; |
| import com.google.gwt.dev.util.Empty; |
| import com.google.gwt.dev.util.JsniRef; |
| import com.google.gwt.dev.util.collect.Lists; |
| |
| import org.eclipse.jdt.core.compiler.CharOperation; |
| import org.eclipse.jdt.internal.compiler.ast.Annotation; |
| import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer; |
| import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.Expression; |
| import org.eclipse.jdt.internal.compiler.ast.MemberValuePair; |
| import org.eclipse.jdt.internal.compiler.ast.SingleMemberAnnotation; |
| import org.eclipse.jdt.internal.compiler.ast.StringLiteral; |
| import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration; |
| import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.BlockScope; |
| import org.eclipse.jdt.internal.compiler.lookup.ClassScope; |
| import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope; |
| import org.eclipse.jdt.internal.compiler.lookup.MethodBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons; |
| import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.TypeBinding; |
| |
| import java.util.List; |
| |
| /** |
| * Checks the validity of ArtificialRescue annotations. |
| * |
| * <ul> |
| * <li>(1) The ArtificialRescue annotation is only used in generated code.</li> |
| * <li>(2) The className value names a type known to GWT (ignoring access rules) |
| * </li> |
| * <li>(3) The methods and fields of the type are known to GWT</li> |
| * </ul> |
| */ |
| public class ArtificialRescueChecker { |
| private class Visitor extends SafeASTVisitor { |
| |
| { |
| assert collectTypes || reportErrors : "No work to be done"; |
| } |
| |
| @Override |
| public void endVisit(TypeDeclaration memberTypeDeclaration, ClassScope scope) { |
| processType(memberTypeDeclaration); |
| } |
| |
| @Override |
| public void endVisit(TypeDeclaration typeDeclaration, |
| CompilationUnitScope scope) { |
| processType(typeDeclaration); |
| } |
| |
| @Override |
| public void endVisitValid(TypeDeclaration localTypeDeclaration, BlockScope scope) { |
| processType(localTypeDeclaration); |
| } |
| |
| private void processArtificialRescue(Annotation rescue) { |
| if (!allowArtificialRescue) { |
| // Goal (1) |
| GWTProblem.recordError(rescue, cud, onlyGeneratedCode(), null); |
| return; |
| } |
| |
| String className = null; |
| String[] methods = Empty.STRINGS; |
| String[] fields = Empty.STRINGS; |
| for (MemberValuePair pair : rescue.memberValuePairs()) { |
| String name = String.valueOf(pair.name); |
| if ("className".equals(name)) { |
| className = pair.value.constant.stringValue(); |
| } else if ("methods".equals(name)) { |
| methods = stringArrayFromValue(pair.value); |
| } else if ("fields".equals(name)) { |
| fields = stringArrayFromValue(pair.value); |
| } |
| } |
| |
| assert className != null; |
| |
| if (collectTypes) { |
| referencedTypes = Lists.add(referencedTypes, className); |
| } |
| |
| boolean isArray = false; |
| while (className.endsWith("[]")) { |
| className = className.substring(0, className.length() - 2); |
| if (collectTypes) { |
| referencedTypes = Lists.add(referencedTypes, className); |
| } |
| isArray = true; |
| } |
| |
| if (!reportErrors) { |
| // Nothing else to do |
| return; |
| } |
| |
| // Goal (2) |
| // Strip off any array-like extensions and just find base type |
| |
| // Fix JSNI primitive type names to something JDT will understand |
| if (isArray && className.length() == 1) { |
| switch (className.charAt(0)) { |
| case 'B': |
| className = "byte"; |
| break; |
| case 'C': |
| className = "char"; |
| break; |
| case 'D': |
| className = "double"; |
| break; |
| case 'F': |
| className = "float"; |
| break; |
| case 'I': |
| className = "int"; |
| break; |
| case 'J': |
| className = "long"; |
| break; |
| case 'S': |
| className = "short"; |
| break; |
| case 'Z': |
| className = "boolean"; |
| break; |
| } |
| } |
| |
| char[][] compoundName = CharOperation.splitOn('.', |
| className.toCharArray()); |
| TypeBinding typeBinding = cud.scope.getType(compoundName, |
| compoundName.length); |
| if (typeBinding == null) { |
| GWTProblem.recordError(rescue, cud, notFound(className), null); |
| } else if (typeBinding instanceof ProblemReferenceBinding) { |
| ProblemReferenceBinding problem = (ProblemReferenceBinding) typeBinding; |
| if (problem.problemId() == ProblemReasons.NotVisible) { |
| // Ignore |
| } else if (problem.problemId() == ProblemReasons.NotFound) { |
| GWTProblem.recordError(rescue, cud, notFound(className), null); |
| } else { |
| GWTProblem.recordError(rescue, cud, |
| unknownProblem(className, problem), null); |
| } |
| } else if (typeBinding instanceof BaseTypeBinding) { |
| // No methods or fields on primitive types (3) |
| if (methods.length > 0) { |
| GWTProblem.recordError(rescue, cud, noMethodsAllowed(), null); |
| } |
| |
| if (fields.length > 0) { |
| GWTProblem.recordError(rescue, cud, noFieldsAllowed(), null); |
| } |
| } else if (typeBinding instanceof ReferenceBinding) { |
| ReferenceBinding ref = (ReferenceBinding) typeBinding; |
| |
| if (isArray) { |
| // No methods or fields on array types (3) |
| if (methods.length > 0) { |
| GWTProblem.recordError(rescue, cud, noMethodsAllowed(), null); |
| } |
| |
| if (fields.length > 0) { |
| GWTProblem.recordError(rescue, cud, noFieldsAllowed(), null); |
| } |
| } else { |
| // Check methods on reference types (3) |
| for (String method : methods) { |
| if (method.contains("@")) { |
| GWTProblem.recordError(rescue, cud, nameAndTypesOnly(), null); |
| continue; |
| } |
| JsniRef jsni = JsniRef.parse("@foo::" + method); |
| if (jsni == null) { |
| GWTProblem.recordError(rescue, cud, badMethodSignature(method), |
| null); |
| continue; |
| } |
| |
| if (jsni.memberName().equals( |
| String.valueOf(ref.compoundName[ref.compoundName.length - 1]))) { |
| // Constructor |
| } else { |
| MethodBinding[] methodBindings = ref.getMethods(jsni.memberName().toCharArray()); |
| if (methodBindings == null || methodBindings.length == 0) { |
| GWTProblem.recordError(rescue, cud, noMethod(className, |
| jsni.memberName()), null); |
| continue; |
| } |
| } |
| } |
| |
| // Check fields on reference types (3) |
| for (String field : fields) { |
| if (ref.getField(field.toCharArray(), false) == null) { |
| GWTProblem.recordError(rescue, cud, unknownField(field), null); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Examine a TypeDeclaration for ArtificialRescue annotations. Delegates to |
| * {@link #processArtificialRescue(Annotation)} to complete the processing. |
| */ |
| private void processType(TypeDeclaration x) { |
| if (x.annotations == null) { |
| return; |
| } |
| |
| for (Annotation a : x.annotations) { |
| if (!ArtificialRescue.class.getName().equals( |
| CharOperation.toString(((ReferenceBinding) a.resolvedType).compoundName))) { |
| continue; |
| } |
| |
| // Sometimes it's a SingleMemberAnnotation, other times it's not |
| Expression value = null; |
| if (a instanceof SingleMemberAnnotation) { |
| value = ((SingleMemberAnnotation) a).memberValue; |
| } else { |
| for (MemberValuePair pair : a.memberValuePairs()) { |
| if ("value".equals(String.valueOf(pair.name))) { |
| value = pair.value; |
| break; |
| } |
| } |
| } |
| |
| assert value != null; |
| if (value instanceof ArrayInitializer) { |
| for (Expression e : ((ArrayInitializer) value).expressions) { |
| processArtificialRescue((Annotation) e); |
| } |
| } else if (value instanceof Annotation) { |
| processArtificialRescue((Annotation) value); |
| } else { |
| throw new InternalCompilerException( |
| "Unable to process annotation with value of type " |
| + value.getClass().getName()); |
| } |
| |
| return; |
| } |
| } |
| |
| private String[] stringArrayFromValue(Expression value) { |
| if (value instanceof StringLiteral) { |
| return new String[] {value.constant.stringValue()}; |
| } else if (value instanceof ArrayInitializer) { |
| ArrayInitializer init = (ArrayInitializer) value; |
| String[] toReturn = new String[init.expressions == null ? 0 |
| : init.expressions.length]; |
| for (int i = 0; i < toReturn.length; i++) { |
| toReturn[i] = init.expressions[i].constant.stringValue(); |
| } |
| return toReturn; |
| } else { |
| throw new InternalCompilerException("Unhandled value type " |
| + value.getClass().getName()); |
| } |
| } |
| } |
| |
| /** |
| * Check the {@link ArtificialRescue} annotations in a CompilationUnit. Errors |
| * are reported through {@link GWTProblem}. |
| */ |
| public static void check(CompilationUnitDeclaration cud, |
| boolean allowArtificialRescue) { |
| new ArtificialRescueChecker(cud, allowArtificialRescue).check(); |
| } |
| |
| /** |
| * Report all types named in {@link ArtificialRescue} annotations in a CUD. No |
| * error checking is done. |
| */ |
| public static List<String> collectReferencedTypes( |
| CompilationUnitDeclaration cud) { |
| return new ArtificialRescueChecker(cud).collect(); |
| } |
| |
| static String badMethodSignature(String method) { |
| return "Bad method signature " + method; |
| } |
| |
| static String nameAndTypesOnly() { |
| return "Only method name and parameter types expected"; |
| } |
| |
| static String noFieldsAllowed() { |
| return "Cannot refer to fields on array or primitive types"; |
| } |
| |
| static String noMethod(String className, String methodName) { |
| return "No method named " + methodName + " in type " + className; |
| } |
| |
| static String noMethodsAllowed() { |
| return "Cannot refer to methods on array or primitive types"; |
| } |
| |
| static String notFound(String className) { |
| return "Could not find type " + className; |
| } |
| |
| static String onlyGeneratedCode() { |
| return "The " + ArtificialRescue.class.getName() |
| + " annotation may only be used in generated code and its use" |
| + " by third parties is not supported."; |
| } |
| |
| static String unknownField(String field) { |
| return "Unknown field " + field; |
| } |
| |
| static String unknownProblem(String className, ProblemReferenceBinding problem) { |
| return "Unknown problem: " |
| + ProblemReferenceBinding.problemReasonString(problem.problemId()) |
| + " " + className; |
| } |
| |
| private final boolean allowArtificialRescue; |
| |
| private boolean collectTypes; |
| |
| private final CompilationUnitDeclaration cud; |
| |
| private List<String> referencedTypes; |
| |
| private boolean reportErrors; |
| |
| private ArtificialRescueChecker(CompilationUnitDeclaration cud) { |
| allowArtificialRescue = true; |
| this.cud = cud; |
| } |
| |
| private ArtificialRescueChecker(CompilationUnitDeclaration cud, |
| boolean allowArtificialRescue) { |
| this.cud = cud; |
| this.allowArtificialRescue = allowArtificialRescue; |
| } |
| |
| private void check() { |
| collectTypes = false; |
| reportErrors = true; |
| cud.traverse(new Visitor(), cud.scope); |
| } |
| |
| private List<String> collect() { |
| collectTypes = true; |
| referencedTypes = Lists.create(); |
| reportErrors = false; |
| cud.traverse(new Visitor(), cud.scope); |
| return referencedTypes; |
| } |
| |
| } |
