/*
* Copyright 2008 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.UnsafeNativeLong;
import com.google.gwt.dev.javac.JSORestrictionsChecker.CheckerState;
import com.google.gwt.dev.jdt.SafeASTVisitor;
import com.google.gwt.dev.jjs.InternalCompilerException;
import com.google.gwt.dev.jjs.SourceInfo;
import com.google.gwt.dev.js.ast.JsContext;
import com.google.gwt.dev.js.ast.JsFunction;
import com.google.gwt.dev.js.ast.JsNameRef;
import com.google.gwt.dev.js.ast.JsVisitor;
import com.google.gwt.dev.util.InstalledHelpInfo;
import com.google.gwt.dev.util.JsniRef;
import com.google.gwt.dev.util.collect.Sets;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.Argument;
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.MethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
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.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.NestedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.UnresolvedReferenceBinding;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;
/**
* Tests for access to Java from JSNI. Issues a warning for:
* <ul>
* <li>JSNI methods with a parameter or return type of long.</li>
* <li>Access from JSNI to a field whose type is long.</li>
* <li>Access from JSNI to a method with a parameter or return type of long.</li>
* <li>JSNI references to anonymous classes.</li>
* </ul>
* All tests also apply for arrays of longs, arrays of arrays of longs, etc.
*/
public class JsniChecker {
/**
* A call-back interface to resolve types.
*/
public interface TypeResolver {
ReferenceBinding resolveType(String typeName);
}
private class JsniDeclChecker extends SafeASTVisitor implements
ClassFileConstants {
@Override
public void endVisit(MethodDeclaration meth, ClassScope scope) {
if (meth.isNative()) {
boolean hasUnsafeLongsAnnotation = hasUnsafeLongsAnnotation(meth, scope);
if (!hasUnsafeLongsAnnotation) {
checkDecl(meth, scope);
}
JsniMethod jsniMethod = jsniMethods.get(meth);
if (jsniMethod != null) {
new JsniRefChecker(meth, hasUnsafeLongsAnnotation).check(jsniMethod.function());
}
}
suppressWarningsStack.pop();
}
@Override
public void endVisit(TypeDeclaration typeDeclaration, ClassScope scope) {
suppressWarningsStack.pop();
}
@Override
public void endVisit(TypeDeclaration typeDeclaration,
CompilationUnitScope scope) {
suppressWarningsStack.pop();
}
@Override
public void endVisitValid(TypeDeclaration typeDeclaration, BlockScope scope) {
suppressWarningsStack.pop();
}
@Override
public boolean visit(MethodDeclaration meth, ClassScope scope) {
suppressWarningsStack.push(getSuppressedWarnings(meth.annotations));
return true;
}
@Override
public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
suppressWarningsStack.push(getSuppressedWarnings(typeDeclaration.annotations));
return true;
}
@Override
public boolean visit(TypeDeclaration typeDeclaration,
CompilationUnitScope scope) {
suppressWarningsStack.push(getSuppressedWarnings(typeDeclaration.annotations));
return true;
}
@Override
public boolean visitValid(TypeDeclaration typeDeclaration, BlockScope scope) {
suppressWarningsStack.push(getSuppressedWarnings(typeDeclaration.annotations));
return true;
}
private void checkDecl(MethodDeclaration meth, ClassScope scope) {
TypeReference returnType = meth.returnType;
if (containsLong(returnType, scope)) {
longAccessError(meth, "Type '" + typeString(returnType)
+ "' may not be returned from a JSNI method");
}
if (meth.arguments != null) {
for (Argument arg : meth.arguments) {
if (containsLong(arg.type, scope)) {
longAccessError(arg, "Parameter '" + String.valueOf(arg.name)
+ "': type '" + typeString(arg.type)
+ "' is not safe to access in JSNI code");
}
}
}
}
private boolean containsLong(final TypeReference type, ClassScope scope) {
return type != null
&& JsniChecker.this.containsLong(type.resolveType(scope));
}
private String typeString(TypeReference type) {
return type.toString();
}
}
private class JsniRefChecker extends JsVisitor {
private transient SourceInfo errorInfo;
private final boolean hasUnsafeLongsAnnotation;
private final MethodDeclaration method;
public JsniRefChecker(MethodDeclaration method,
boolean hasUnsafeLongsAnnotation) {
this.method = method;
this.hasUnsafeLongsAnnotation = hasUnsafeLongsAnnotation;
}
public void check(JsFunction function) {
this.accept(function);
}
@Override
public void endVisit(JsNameRef x, JsContext ctx) {
this.errorInfo = x.getSourceInfo();
String ident = x.getIdent();
if (ident.charAt(0) == '@') {
JsniRef jsniRef = JsniRef.parse(ident);
if (jsniRef == null) {
emitError("Malformed JSNI identifier '" + ident + "'");
} else {
Binding binding = checkRef(jsniRef, x.getQualifier() != null,
ctx.isLvalue());
if (binding != null) {
jsniRefs.put(ident, binding);
}
}
}
this.errorInfo = null;
}
private FieldBinding checkFieldRef(ReferenceBinding clazz, JsniRef jsniRef,
boolean hasQualifier, boolean isLvalue) {
assert jsniRef.isField();
FieldBinding target = getField(clazz, jsniRef);
if (target == null) {
emitError("Referencing field '" + jsniRef.className() + "."
+ jsniRef.memberName() + "': unable to resolve field");
return null;
}
if (target.isDeprecated()) {
emitWarning("deprecation",
"Referencing deprecated field '" + jsniRef.className() + "."
+ jsniRef.memberName() + "'");
}
if (isLvalue && target.constant() != Constant.NotAConstant) {
emitError("Illegal assignment to compile-time constant '"
+ jsniRef.className() + "." + jsniRef.memberName() + "'");
}
if (target.isStatic() && hasQualifier) {
emitError("Unnecessary qualifier on static field '"
+ jsniRef.className() + "." + jsniRef.memberName() + "'");
} else if (!target.isStatic() && !hasQualifier) {
emitError("Missing qualifier on instance field '" + jsniRef.className()
+ "." + jsniRef.memberName() + "'");
}
if (hasUnsafeLongsAnnotation) {
return target;
}
if (containsLong(target.type)) {
emitError("Referencing field '" + jsniRef.className() + "."
+ jsniRef.memberName() + "': type '" + typeString(target.type)
+ "' is not safe to access in JSNI code");
}
return target;
}
private MethodBinding checkMethodRef(ReferenceBinding clazz,
JsniRef jsniRef, boolean hasQualifier, boolean isLvalue) {
assert jsniRef.isMethod();
MethodBinding target = getMethod(clazz, jsniRef);
if (target == null) {
emitError("Referencing method '" + jsniRef.className() + "."
+ jsniRef.memberSignature() + "': unable to resolve method");
return null;
}
if (target.isDeprecated()) {
emitWarning("deprecation",
"Referencing deprecated method '" + jsniRef.className() + "."
+ jsniRef.memberName() + "'");
}
if (isLvalue) {
emitError("Illegal assignment to method '" + jsniRef.className() + "."
+ jsniRef.memberName() + "'");
}
boolean needsQualifer = !target.isStatic() && !target.isConstructor();
if (!needsQualifer && hasQualifier) {
emitError("Unnecessary qualifier on static method '"
+ jsniRef.className() + "." + jsniRef.memberName() + "'");
} else if (needsQualifer && !hasQualifier) {
emitError("Missing qualifier on instance method '"
+ jsniRef.className() + "." + jsniRef.memberName() + "'");
}
if (!target.isStatic() && JSORestrictionsChecker.isJso(clazz)) {
emitError("Referencing method '" + jsniRef.className() + "."
+ jsniRef.memberSignature()
+ "': references to instance methods in overlay types are illegal");
}
if (checkerState.isJsoInterface(clazz)) {
String implementor = checkerState.getJsoImplementor(clazz);
emitError("Referencing interface method '" + jsniRef.className() + "."
+ jsniRef.memberSignature() + "': implemented by '" + implementor
+ "'; references to instance methods in overlay types are illegal"
+ "; use a stronger type or a Java trampoline method");
}
if (hasUnsafeLongsAnnotation) {
return target;
}
if (containsLong(target.returnType)) {
emitError("Referencing method '" + jsniRef.className() + "."
+ jsniRef.memberName() + "': return type '"
+ typeString(target.returnType)
+ "' is not safe to access in JSNI code");
}
if (target.parameters != null) {
int i = 0;
for (TypeBinding paramType : target.parameters) {
++i;
if (containsLong(paramType)) {
// It would be nice to print the parameter name, but how to find it?
emitError("Parameter " + i + " of method '" + jsniRef.className()
+ "." + jsniRef.memberName() + "': type '"
+ typeString(paramType)
+ "' may not be passed out of JSNI code");
}
}
}
return target;
}
private Binding checkRef(JsniRef jsniRef, boolean hasQualifier,
boolean isLvalue) {
String className = jsniRef.className();
if ("null".equals(className)) {
if (jsniRef.isField()) {
if (!"nullField".equals(jsniRef.memberName())) {
emitError("Referencing field '" + jsniRef.className() + "."
+ jsniRef.memberName()
+ "': 'nullField' is the only legal field reference for 'null'");
}
} else {
if (!"nullMethod()".equals(jsniRef.memberSignature())) {
emitError("Referencing method '" + jsniRef.className() + "."
+ jsniRef.memberSignature()
+ "': 'nullMethod()' is the only legal method for 'null'");
}
return null;
}
return null;
}
boolean isArray = false;
int dims = 0;
while (className.endsWith("[]")) {
++dims;
isArray = true;
className = className.substring(0, className.length() - 2);
}
boolean isPrimitive;
ReferenceBinding clazz;
TypeBinding binding = method.scope.getBaseType(className.toCharArray());
if (binding != null) {
isPrimitive = true;
clazz = null;
} else {
isPrimitive = false;
binding = clazz = findClass(className);
}
// TODO(deprecation): remove this support eventually.
if (binding == null && className.length() == 1
&& "ZBCDFIJSV".indexOf(className.charAt(0)) >= 0) {
isPrimitive = true;
binding = getTypeBinding(className.charAt(0));
assert binding != null;
JsniCollector.reportJsniWarning(
errorInfo,
method,
"Referencing primitive type '" + className
+ "': this is deprecated, use '"
+ String.valueOf(binding.sourceName()) + "' instead");
}
if ((binding == null && looksLikeAnonymousClass(jsniRef))
|| (binding != null && binding.isAnonymousType())) {
emitError("Referencing class '" + className
+ "': JSNI references to anonymous classes are illegal");
return null;
} else if (binding == null) {
emitError("Referencing class '" + className
+ "': unable to resolve class");
return null;
}
if (clazz != null && clazz.isDeprecated()) {
emitWarning("deprecation", "Referencing deprecated class '" + className
+ "'");
}
if (jsniRef.isField() && "class".equals(jsniRef.memberName())) {
if (isLvalue) {
emitError("Illegal assignment to class literal '"
+ jsniRef.className() + ".class'");
return null;
}
// Reference to the class itself.
if (isArray) {
return method.scope.createArrayType(binding, dims);
} else {
return binding;
}
}
if (isArray || isPrimitive) {
emitError("Referencing member '" + jsniRef.className() + "."
+ jsniRef.memberName()
+ "': 'class' is the only legal reference for "
+ (isArray ? "array" : "primitive") + " types");
return null;
}
assert clazz != null;
if (jsniRef.isMethod()) {
return checkMethodRef(clazz, jsniRef, hasQualifier, isLvalue);
} else {
return checkFieldRef(clazz, jsniRef, hasQualifier, isLvalue);
}
}
private void emitError(String msg) {
JsniCollector.reportJsniError(errorInfo, method, msg);
}
private void emitWarning(String category, String msg) {
for (Set<String> suppressWarnings : suppressWarningsStack) {
if (suppressWarnings.contains(category)
|| suppressWarnings.contains("all")) {
return;
}
}
JsniCollector.reportJsniWarning(errorInfo, method, msg);
}
private ReferenceBinding findClass(String className) {
ReferenceBinding binding = typeResolver.resolveType(className);
assert !(binding instanceof ProblemReferenceBinding);
assert !(binding instanceof UnresolvedReferenceBinding);
return binding;
}
private char[][] getCompoundName(JsniRef jsniRef) {
String className = jsniRef.className().replace('$', '.');
char[][] compoundName = CharOperation.splitOn('.',
className.toCharArray());
return compoundName;
}
private FieldBinding getField(ReferenceBinding clazz, JsniRef jsniRef) {
assert jsniRef.isField();
return clazz.getField(jsniRef.memberName().toCharArray(), false);
}
private MethodBinding getMethod(ReferenceBinding clazz, JsniRef jsniRef) {
assert jsniRef.isMethod();
String methodName = jsniRef.memberName();
if ("new".equals(methodName)) {
for (MethodBinding findMethod : clazz.getMethods(INIT_CTOR_CHARS)) {
StringBuilder methodSig = new StringBuilder();
if (clazz instanceof NestedTypeBinding) {
// Match synthetic args for enclosing instances.
NestedTypeBinding nestedBinding = (NestedTypeBinding) clazz;
if (nestedBinding.enclosingInstances != null) {
for (int i = 0; i < nestedBinding.enclosingInstances.length; ++i) {
SyntheticArgumentBinding arg = nestedBinding.enclosingInstances[i];
methodSig.append(arg.type.signature());
}
}
}
if (findMethod.parameters != null) {
for (TypeBinding binding : findMethod.parameters) {
methodSig.append(binding.signature());
}
}
if (methodSig.toString().equals(jsniRef.paramTypesString())) {
return findMethod;
}
}
} else {
Queue<ReferenceBinding> work = new LinkedList<ReferenceBinding>();
work.add(clazz);
while (!work.isEmpty()) {
clazz = work.remove();
for (MethodBinding findMethod : clazz.getMethods(methodName.toCharArray())) {
if (paramTypesMatch(findMethod, jsniRef)) {
return findMethod;
}
}
ReferenceBinding[] superInterfaces = clazz.superInterfaces();
if (superInterfaces != null) {
work.addAll(Arrays.asList(superInterfaces));
}
ReferenceBinding superclass = clazz.superclass();
if (superclass != null) {
work.add(superclass);
}
}
}
return null;
}
@Deprecated
private TypeBinding getTypeBinding(char c) {
switch (c) {
case 'I':
return TypeBinding.INT;
case 'Z':
return TypeBinding.BOOLEAN;
case 'V':
return TypeBinding.VOID;
case 'C':
return TypeBinding.CHAR;
case 'D':
return TypeBinding.DOUBLE;
case 'B':
return TypeBinding.BYTE;
case 'F':
return TypeBinding.FLOAT;
case 'J':
return TypeBinding.LONG;
case 'S':
return TypeBinding.SHORT;
default:
return null;
}
}
private boolean looksLikeAnonymousClass(JsniRef jsniRef) {
char[][] compoundName = getCompoundName(jsniRef);
for (char[] part : compoundName) {
if (Character.isDigit(part[0])) {
return true;
}
}
return false;
}
private boolean paramTypesMatch(MethodBinding method, JsniRef jsniRef) {
if (jsniRef.matchesAnyOverload()) {
return true;
}
StringBuilder methodSig = new StringBuilder();
if (method.parameters != null) {
for (TypeBinding binding : method.parameters) {
methodSig.append(binding.signature());
}
}
return methodSig.toString().equals(jsniRef.paramTypesString());
}
private String typeString(TypeBinding type) {
return String.valueOf(type.shortReadableName());
}
}
private static final char[] INIT_CTOR_CHARS = "<init>".toCharArray();
private static final char[][] UNSAFE_LONG_ANNOTATION_CHARS = CharOperation.splitOn(
'.', UnsafeNativeLong.class.getName().toCharArray());
/**
* Checks an entire
* {@link org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration}.
*
*/
public static void check(CompilationUnitDeclaration cud,
CheckerState checkerState,
Map<MethodDeclaration, JsniMethod> jsniMethods,
Map<String, Binding> jsniRefs, TypeResolver typeResolver) {
new JsniChecker(cud, checkerState, typeResolver, jsniMethods, jsniRefs).check();
}
static Set<String> getSuppressedWarnings(Annotation[] annotations) {
if (annotations != null) {
for (Annotation a : annotations) {
if (SuppressWarnings.class.getName().equals(
CharOperation.toString(((ReferenceBinding) a.resolvedType).compoundName))) {
for (MemberValuePair pair : a.memberValuePairs()) {
if (String.valueOf(pair.name).equals("value")) {
Expression valueExpr = pair.value;
if (valueExpr instanceof StringLiteral) {
// @SuppressWarnings("Foo")
return Sets.create(((StringLiteral) valueExpr).constant.stringValue().toLowerCase(
Locale.ENGLISH));
} else if (valueExpr instanceof ArrayInitializer) {
// @SuppressWarnings({ "Foo", "Bar"})
ArrayInitializer ai = (ArrayInitializer) valueExpr;
String[] values = new String[ai.expressions.length];
for (int i = 0, j = values.length; i < j; i++) {
values[i] = ((StringLiteral) ai.expressions[i]).constant.stringValue().toLowerCase(
Locale.ENGLISH);
}
return Sets.create(values);
} else {
throw new InternalCompilerException(
"Unable to analyze SuppressWarnings annotation");
}
}
}
}
}
}
return Sets.create();
}
private final CheckerState checkerState;
private final CompilationUnitDeclaration cud;
private final Map<MethodDeclaration, JsniMethod> jsniMethods;
private final Map<String, Binding> jsniRefs;
private final Stack<Set<String>> suppressWarningsStack = new Stack<Set<String>>();
private final TypeResolver typeResolver;
private JsniChecker(CompilationUnitDeclaration cud,
CheckerState checkerState, TypeResolver typeResolver,
Map<MethodDeclaration, JsniMethod> jsniMethods,
Map<String, Binding> jsniRefs) {
this.checkerState = checkerState;
this.cud = cud;
this.typeResolver = typeResolver;
this.jsniMethods = jsniMethods;
this.jsniRefs = jsniRefs;
}
private void check() {
// First check the declarations.
cud.traverse(new JsniDeclChecker(), cud.scope);
}
/**
* Check whether the argument type is the <code>long</code> primitive type. If
* the argument is <code>null</code>, returns <code>false</code>.
*/
private boolean containsLong(TypeBinding type) {
if (type instanceof BaseTypeBinding) {
BaseTypeBinding btb = (BaseTypeBinding) type;
if (btb.id == TypeIds.T_long) {
return true;
}
}
return false;
}
private boolean hasUnsafeLongsAnnotation(MethodDeclaration meth,
ClassScope scope) {
if (meth.annotations != null) {
for (Annotation annot : meth.annotations) {
if (isUnsafeLongAnnotation(annot, scope)) {
return true;
}
}
}
return false;
}
private boolean isUnsafeLongAnnotation(Annotation annot, ClassScope scope) {
if (annot.type != null) {
TypeBinding resolved = annot.type.resolveType(scope);
if (resolved != null) {
if (resolved instanceof ReferenceBinding) {
ReferenceBinding rb = (ReferenceBinding) resolved;
if (CharOperation.equals(rb.compoundName,
UNSAFE_LONG_ANNOTATION_CHARS)) {
return true;
}
}
}
}
return false;
}
private void longAccessError(ASTNode node, String message) {
GWTProblem.recordError(node, cud, message, new InstalledHelpInfo(
"longJsniRestriction.html"));
}
}