| /* |
| * 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.jjs.impl; |
| |
| import com.google.gwt.dev.javac.JsniCollector; |
| import com.google.gwt.dev.jdt.AbstractCompiler.CompilationResults; |
| import com.google.gwt.dev.jdt.SafeASTVisitor; |
| import com.google.gwt.dev.jjs.HasSourceInfo; |
| import com.google.gwt.dev.jjs.InternalCompilerException; |
| import com.google.gwt.dev.jjs.SourceInfo; |
| import com.google.gwt.dev.jjs.SourceOrigin; |
| import com.google.gwt.dev.jjs.ast.JClassType; |
| import com.google.gwt.dev.jjs.ast.JConstructor; |
| import com.google.gwt.dev.jjs.ast.JDeclaredType; |
| import com.google.gwt.dev.jjs.ast.JEnumType; |
| import com.google.gwt.dev.jjs.ast.JField; |
| import com.google.gwt.dev.jjs.ast.JField.Disposition; |
| import com.google.gwt.dev.jjs.ast.JInterfaceType; |
| import com.google.gwt.dev.jjs.ast.JLocal; |
| import com.google.gwt.dev.jjs.ast.JMethod; |
| import com.google.gwt.dev.jjs.ast.JMethodBody; |
| import com.google.gwt.dev.jjs.ast.JNullType; |
| import com.google.gwt.dev.jjs.ast.JParameter; |
| import com.google.gwt.dev.jjs.ast.JProgram; |
| import com.google.gwt.dev.jjs.ast.JReferenceType; |
| import com.google.gwt.dev.jjs.ast.JType; |
| import com.google.gwt.dev.jjs.ast.js.JsniMethodBody; |
| import com.google.gwt.dev.js.JsAbstractSymbolResolver; |
| import com.google.gwt.dev.js.ast.JsFunction; |
| import com.google.gwt.dev.js.ast.JsName; |
| import com.google.gwt.dev.js.ast.JsNameRef; |
| import com.google.gwt.dev.js.ast.JsNode; |
| import com.google.gwt.dev.js.ast.JsParameter; |
| import com.google.gwt.dev.js.ast.JsProgram; |
| import com.google.gwt.dev.util.log.speedtracer.CompilerEventType; |
| import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger; |
| import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event; |
| |
| import org.eclipse.jdt.internal.compiler.CompilationResult; |
| import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.AllocationExpression; |
| import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.Argument; |
| import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.Expression; |
| import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration; |
| import org.eclipse.jdt.internal.compiler.ast.Statement; |
| import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration; |
| import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding; |
| 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.LocalTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.MethodBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.MethodScope; |
| import org.eclipse.jdt.internal.compiler.lookup.NestedTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.SyntheticMethodBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.TypeBinding; |
| import org.eclipse.jdt.internal.compiler.util.Util; |
| |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * This is a Builder for {@link TypeMap}. The whole point of this pass is to |
| * create raw unfinished, unlinked AST nodes for types, methods, fields, and |
| * parameters, and to map the original JDT nodes to these AST nodes. That way |
| * when GenerateJavaDom runs, it just uses the TypeMap output from this Builder |
| * to retrieve whatever referenceable nodes it needs without worrying about |
| * whether they need to be created. Building our AST from JDT starts here. |
| */ |
| public class BuildTypeMap { |
| |
| /** |
| * Creates JNodes for every method, field, initializer, parameter, and local |
| * and memorizes the mapping from the JDT Binding to the corresponding JNode |
| * for each thing created. Note that this pass also 1) sets up the super |
| * type(s) for any member or local types created in BuildTypeMapVisitor (see |
| * the comments there about why it had to be deferred). 2) adds each |
| * user-defined type to a flat list. 3) Creates JNodes for all methods and |
| * variables and memorizes the mapping from the JDT Binding to the |
| * corresponding JNode for each created method and variable. 4) Maps all |
| * synthetic arguments and fields for nested and local classes. 5) Slurps in |
| * JSNI code for native methods as an opaque string. |
| * |
| * Note that methods and fields are not added to their classes here, that |
| * isn't done until {@link GenerateJavaAST}. |
| */ |
| private class BuildDeclMapVisitor extends SafeASTVisitor { |
| |
| private String currentFileName; |
| private int[] currentSeparatorPositions; |
| private final List<TypeDeclaration> typeDecls = new ArrayList<TypeDeclaration>(); |
| |
| public TypeDeclaration[] getTypeDeclarataions() { |
| return typeDecls.toArray(new TypeDeclaration[typeDecls.size()]); |
| } |
| |
| @Override |
| public boolean visit(AnnotationMethodDeclaration methodDeclaration, ClassScope scope) { |
| return visit((MethodDeclaration) methodDeclaration, scope); |
| } |
| |
| @Override |
| public boolean visit(Argument argument, BlockScope scope) { |
| try { |
| if (scope == scope.methodScope()) { |
| return true; |
| } |
| |
| JMethodBody enclosingBody = findEnclosingMethod(scope); |
| if (enclosingBody == null) { |
| // Happens in the case of external types |
| return true; |
| } |
| SourceInfo info = makeSourceInfo(argument, enclosingBody.getMethod()); |
| LocalVariableBinding b = argument.binding; |
| JType localType = getType(b.type); |
| JLocal newLocal = |
| JProgram.createLocal(info, String.valueOf(argument.name), localType, b.isFinal(), |
| enclosingBody); |
| typeMap.put(b, newLocal); |
| return true; |
| } catch (Throwable e) { |
| throw translateException(argument, e); |
| } |
| } |
| |
| @Override |
| public boolean visit(ConstructorDeclaration ctorDecl, ClassScope scope) { |
| try { |
| MethodBinding b = ctorDecl.binding; |
| JClassType enclosingType = (JClassType) getType(scope.enclosingSourceType()); |
| SourceInfo info = makeSourceInfo(ctorDecl, enclosingType); |
| processConstructor(b, ctorDecl, info); |
| return true; |
| } catch (Throwable e) { |
| throw translateException(ctorDecl, e); |
| } |
| } |
| |
| @Override |
| public boolean visit(FieldDeclaration fieldDeclaration, MethodScope scope) { |
| try { |
| FieldBinding b = fieldDeclaration.binding; |
| JDeclaredType enclosingType = (JDeclaredType) getType(scope.enclosingSourceType()); |
| SourceInfo info = makeSourceInfo(fieldDeclaration, enclosingType); |
| Expression initialization = fieldDeclaration.initialization; |
| if (initialization != null && initialization instanceof AllocationExpression |
| && ((AllocationExpression) initialization).enumConstant != null) { |
| createEnumField(info, b, enclosingType); |
| } else { |
| createField(info, b, enclosingType); |
| } |
| return true; |
| } catch (Throwable e) { |
| throw translateException(fieldDeclaration, e); |
| } |
| } |
| |
| @Override |
| public boolean visit(LocalDeclaration localDeclaration, BlockScope scope) { |
| try { |
| LocalVariableBinding b = localDeclaration.binding; |
| TypeBinding resolvedType = localDeclaration.type.resolvedType; |
| JType localType; |
| if (resolvedType.constantPoolName() != null) { |
| localType = getType(resolvedType); |
| } else { |
| // Special case, a statically unreachable local type. |
| localType = JNullType.INSTANCE; |
| } |
| JMethodBody enclosingBody = findEnclosingMethod(scope); |
| if (enclosingBody == null) { |
| // Happens in the case of external types |
| return true; |
| } |
| SourceInfo info = makeSourceInfo(localDeclaration, enclosingBody.getMethod()); |
| JLocal newLocal = |
| JProgram.createLocal(info, String.valueOf(localDeclaration.name), localType, b |
| .isFinal(), enclosingBody); |
| typeMap.put(b, newLocal); |
| return true; |
| } catch (Throwable e) { |
| throw translateException(localDeclaration, e); |
| } |
| } |
| |
| @Override |
| public boolean visit(MethodDeclaration methodDeclaration, ClassScope scope) { |
| try { |
| MethodBinding b = methodDeclaration.binding; |
| JDeclaredType enclosingType = (JDeclaredType) getType(scope.enclosingSourceType()); |
| SourceInfo info = makeSourceInfo(methodDeclaration, enclosingType); |
| JMethod newMethod = processMethodBinding(b, enclosingType, info); |
| SourceInfo methodInfo = makeSourceInfo(methodDeclaration, newMethod); |
| mapParameters(newMethod, methodDeclaration, methodInfo); |
| info.addCorrelation(info.getCorrelator().by(newMethod)); |
| |
| if (newMethod.isNative()) { |
| processNativeMethod(methodDeclaration, info, enclosingType, newMethod); |
| } |
| |
| return true; |
| } catch (Throwable e) { |
| throw translateException(methodDeclaration, e); |
| } |
| } |
| |
| @Override |
| public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope scope) { |
| return process(memberTypeDeclaration); |
| } |
| |
| @Override |
| public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) { |
| return process(typeDeclaration); |
| } |
| |
| @Override |
| public boolean visitValid(TypeDeclaration localTypeDeclaration, BlockScope scope) { |
| return process(localTypeDeclaration); |
| } |
| |
| private JField createEnumField(SourceInfo info, FieldBinding binding, |
| JReferenceType enclosingType) { |
| JType type = getType(binding.type); |
| JField field = |
| program.createEnumField(info, String.valueOf(binding.name), (JEnumType) enclosingType, |
| (JClassType) type, binding.original().id); |
| info.addCorrelation(info.getCorrelator().by(field)); |
| typeMap.put(binding, field); |
| return field; |
| } |
| |
| private JMethodBody findEnclosingMethod(BlockScope scope) { |
| JMethod method; |
| MethodScope methodScope = scope.methodScope(); |
| if (methodScope.isInsideInitializer()) { |
| JDeclaredType enclosingType = |
| (JDeclaredType) getType(scope.classScope().referenceContext.binding); |
| if (methodScope.isStatic) { |
| // clinit |
| method = enclosingType.getMethods().get(0); |
| } else { |
| // init |
| assert (enclosingType instanceof JClassType); |
| method = enclosingType.getMethods().get(1); |
| } |
| } else { |
| AbstractMethodDeclaration referenceMethod = methodScope.referenceMethod(); |
| method = (JMethod) typeMap.get(referenceMethod.binding); |
| } |
| assert !method.isNative() && !method.isAbstract(); |
| return (JMethodBody) (method.isExternal() ? null : method.getBody()); |
| } |
| |
| private SourceInfo makeSourceInfo(AbstractMethodDeclaration methodDecl, HasSourceInfo enclosing) { |
| int startLine = |
| Util.getLineNumber(methodDecl.sourceStart, currentSeparatorPositions, 0, |
| currentSeparatorPositions.length - 1); |
| SourceOrigin toReturn = |
| SourceOrigin.create(methodDecl.sourceStart, methodDecl.bodyEnd, startLine, |
| currentFileName); |
| if (enclosing != null) { |
| return enclosing.getSourceInfo().makeChild(toReturn); |
| } |
| return toReturn; |
| } |
| |
| private SourceInfo makeSourceInfo(Statement stmt, HasSourceInfo enclosing) { |
| int startLine = |
| Util.getLineNumber(stmt.sourceStart, currentSeparatorPositions, 0, |
| currentSeparatorPositions.length - 1); |
| SourceOrigin toReturn = |
| SourceOrigin.create(stmt.sourceStart, stmt.sourceEnd, startLine, currentFileName); |
| if (enclosing != null) { |
| return enclosing.getSourceInfo().makeChild(toReturn); |
| } |
| return toReturn; |
| } |
| |
| /** |
| * Add synthetic fields, setup super types. You'll notice that we DON'T have |
| * any concept of "inner" or "outer" types in our AST. Truth is, we found it |
| * easier to simply model everything as flat classes and emulate the nesting |
| * behavior (and final local access on local classes). It's much closer to |
| * how we'll eventually be generating JavaScript code (code generation is |
| * more straightforward), it makes for fewer kinds of things to worry about |
| * when optimizing (more aggressive optimizations), and it's how Java |
| * actually implements the stuff under the hood anyway. |
| */ |
| private boolean process(TypeDeclaration typeDeclaration) { |
| CompilationResult compResult = typeDeclaration.compilationResult; |
| currentSeparatorPositions = compResult.lineSeparatorPositions; |
| currentFileName = String.valueOf(compResult.fileName); |
| |
| if (BuildTypeMap.this.process(typeDeclaration.binding)) { |
| if (!linker.isExternalType(dotify(typeDeclaration.binding.compoundName))) { |
| typeDecls.add(typeDeclaration); |
| } |
| return true; |
| } |
| |
| return false; |
| } |
| |
| private void processNativeMethod(MethodDeclaration methodDeclaration, SourceInfo info, |
| JDeclaredType enclosingType, JMethod newMethod) { |
| // TODO: use existing parsed JSNI functions from CompilationState. |
| // Handle JSNI block |
| char[] source = methodDeclaration.compilationResult().getCompilationUnit().getContents(); |
| String unitSource = String.valueOf(source); |
| JsFunction jsFunction = |
| JsniCollector.parseJsniFunction(methodDeclaration, unitSource, enclosingType.getName(), |
| info, jsProgram.getScope()); |
| if (jsFunction != null) { |
| jsFunction.setFromJava(true); |
| ((JsniMethodBody) newMethod.getBody()).setFunc(jsFunction); |
| // Ensure that we've resolved the parameter and local references within |
| // the JSNI method for later pruning. |
| JsParameterResolver localResolver = new JsParameterResolver(jsFunction); |
| localResolver.accept(jsFunction); |
| } |
| } |
| |
| private InternalCompilerException translateException(AbstractMethodDeclaration amd, Throwable e) { |
| if (e instanceof VirtualMachineError) { |
| // Always rethrow VM errors (an attempt to wrap may fail). |
| throw (VirtualMachineError) e; |
| } |
| InternalCompilerException ice; |
| if (e instanceof InternalCompilerException) { |
| ice = (InternalCompilerException) e; |
| } else { |
| ice = new InternalCompilerException("Error building type map", e); |
| } |
| ice.addNode(amd.getClass().getName(), amd.toString(), makeSourceInfo(amd, null)); |
| return ice; |
| } |
| |
| private InternalCompilerException translateException(Statement stmt, Throwable e) { |
| if (e instanceof VirtualMachineError) { |
| // Always rethrow VM errors (an attempt to wrap may fail). |
| throw (VirtualMachineError) e; |
| } |
| InternalCompilerException ice; |
| if (e instanceof InternalCompilerException) { |
| ice = (InternalCompilerException) e; |
| } else { |
| ice = new InternalCompilerException("Error building type map", e); |
| } |
| ice.addNode(stmt.getClass().getName(), stmt.toString(), makeSourceInfo(stmt, null)); |
| return ice; |
| } |
| } |
| |
| /** |
| * Creates JNodes for every type and memorizes the mapping from the JDT |
| * Binding to the corresponding JNode for each created type. Note that since |
| * there could be forward references, it is not possible to set up super |
| * types; it must be done is a subsequent pass. |
| */ |
| private class BuildTypeMapVisitor extends SafeASTVisitor { |
| |
| @Override |
| public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope scope) { |
| return process(memberTypeDeclaration); |
| } |
| |
| @Override |
| public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) { |
| return process(typeDeclaration); |
| } |
| |
| @Override |
| public boolean visitValid(TypeDeclaration localTypeDeclaration, BlockScope scope) { |
| assert (TypeDeclaration.kind(localTypeDeclaration.modifiers) != TypeDeclaration.INTERFACE_DECL); |
| return process(localTypeDeclaration); |
| } |
| |
| private SourceInfo makeSourceInfo(TypeDeclaration typeDecl) { |
| CompilationResult compResult = typeDecl.compilationResult; |
| int[] indexes = compResult.lineSeparatorPositions; |
| String fileName = String.valueOf(compResult.fileName); |
| int startLine = Util.getLineNumber(typeDecl.sourceStart, indexes, 0, indexes.length - 1); |
| return program.createSourceInfo(typeDecl.sourceStart, typeDecl.bodyEnd, startLine, fileName); |
| } |
| |
| private boolean process(TypeDeclaration typeDeclaration) { |
| try { |
| SourceTypeBinding binding = typeDeclaration.binding; |
| String name = dotify(binding.compoundName); |
| if (binding instanceof LocalTypeBinding) { |
| char[] localName = binding.constantPoolName(); |
| name = new String(localName).replace('/', '.'); |
| } |
| |
| SourceInfo info = makeSourceInfo(typeDeclaration); |
| typeMap.put(binding, createType(name, info, binding)); |
| return true; |
| } catch (Throwable e) { |
| throw translateException(typeDeclaration, e); |
| } |
| } |
| |
| private InternalCompilerException translateException(TypeDeclaration typeDecl, Throwable e) { |
| if (e instanceof VirtualMachineError) { |
| // Always rethrow VM errors (an attempt to wrap may fail). |
| throw (VirtualMachineError) e; |
| } |
| InternalCompilerException ice; |
| if (e instanceof InternalCompilerException) { |
| ice = (InternalCompilerException) e; |
| } else { |
| ice = new InternalCompilerException("Error building type map", e); |
| } |
| ice.addNode(typeDecl.getClass().getName(), typeDecl.toString(), makeSourceInfo(typeDecl)); |
| return ice; |
| } |
| } |
| |
| private class ExternalTypeCreator implements ExternalTypeTask { |
| |
| public void process(String klass, BinaryTypeBinding binding) { |
| if (program.getFromTypeMap(klass) == null) { |
| // NB(tobyr) There are a few cases where certain compiler intrinsic |
| // types are only needed if the program references them |
| // (e.g. boxed numeric types). If we don't have the binding for those |
| // types, we can safely ignore it. |
| createExternalType(klass, binding); |
| } |
| } |
| } |
| |
| private class ExternalTypeResolver implements ExternalTypeTask { |
| |
| public void process(String klass, BinaryTypeBinding binding) { |
| if (binding != null) { |
| JDeclaredType type = program.getFromTypeMap(klass); |
| resolve(type, binding); |
| } |
| } |
| } |
| |
| private interface ExternalTypeTask { |
| |
| void process(String klass, BinaryTypeBinding binding); |
| } |
| |
| /** |
| * Resolves the scope of JS identifiers solely within the scope of a method. |
| */ |
| private static class JsParameterResolver extends JsAbstractSymbolResolver { |
| private final JsFunction jsFunction; |
| |
| public JsParameterResolver(JsFunction jsFunction) { |
| this.jsFunction = jsFunction; |
| } |
| |
| @Override |
| public void resolve(JsNameRef x) { |
| // Only resolve unqualified names |
| if (x.getQualifier() == null) { |
| JsName name = getScope().findExistingName(x.getIdent()); |
| |
| // Ensure that we're resolving a name from the function's parameters |
| JsNode node = name == null ? null : name.getStaticRef(); |
| if (node instanceof JsParameter) { |
| JsParameter param = (JsParameter) node; |
| if (jsFunction.getParameters().contains(param)) { |
| x.resolve(name); |
| } |
| } |
| } |
| } |
| } |
| |
| // TODO: Remove this overload altogether at some point. |
| |
| public static TypeDeclaration[] exec(TypeMap typeMap, CompilationResults results, |
| JsProgram jsProgram, TypeLinker linker) { |
| BuildTypeMap btm = new BuildTypeMap(typeMap, jsProgram, linker, results.compiledUnits); |
| Event buildTypeMapEvent = SpeedTracerLogger.start(CompilerEventType.BUILD_TYPE_MAP_FOR_AST); |
| btm.createPeersForUnits(); |
| btm.resolveExternalTypes(results.binaryBindings); |
| TypeDeclaration[] result = btm.createPeersForNonTypeDecls(); |
| buildTypeMapEvent.end(); |
| return result; |
| } |
| |
| public static TypeDeclaration[] exec(TypeMap typeMap, CompilationUnitDeclaration[] unitDecls, |
| JsProgram jsProgram) { |
| CompilationResults results = |
| new CompilationResults(unitDecls, new HashMap<String, BinaryTypeBinding>(0)); |
| return exec(typeMap, results, jsProgram, TypeLinker.NULL_TYPE_LINKER); |
| } |
| |
| static String dotify(char[][] name) { |
| StringBuffer result = new StringBuffer(); |
| for (int i = 0; i < name.length; ++i) { |
| if (i > 0) { |
| result.append('.'); |
| } |
| |
| result.append(name[i]); |
| } |
| return result.toString(); |
| } |
| |
| private final JsProgram jsProgram; |
| private final TypeLinker linker; |
| private final JProgram program; |
| private final TypeMap typeMap; |
| private final CompilationUnitDeclaration[] unitDecls; |
| |
| private BuildTypeMap(TypeMap typeMap, JsProgram jsProgram, TypeLinker linker, |
| CompilationUnitDeclaration[] unitDecls) { |
| this.typeMap = typeMap; |
| this.program = typeMap.getProgram(); |
| this.jsProgram = jsProgram; |
| this.linker = linker; |
| this.unitDecls = unitDecls; |
| } |
| |
| private void addThrownExceptions(MethodBinding methodBinding, JMethod method) { |
| for (ReferenceBinding thrownBinding : methodBinding.thrownExceptions) { |
| JClassType type = (JClassType) getType(thrownBinding.erasure()); |
| method.addThrownException(type); |
| } |
| } |
| |
| private JDeclaredType createExternalType(String name, ReferenceBinding binding) { |
| char[] chars = binding.getFileName(); |
| String fileName = chars == null ? "" : String.valueOf(chars); |
| SourceInfo sourceInfo = SourceOrigin.create(0, fileName); |
| JDeclaredType type = createType(name, sourceInfo, binding); |
| typeMap.put(binding, type); |
| return type; |
| } |
| |
| private JField createField(SourceInfo info, FieldBinding binding, JDeclaredType enclosingType) { |
| JType type = getType(binding.type); |
| JField field = |
| program.createField(info, String.valueOf(binding.name), enclosingType, type, binding |
| .isStatic(), GwtAstBuilder.getFieldDisposition(binding)); |
| typeMap.put(binding, field); |
| info.addCorrelation(info.getCorrelator().by(field)); |
| return field; |
| } |
| |
| private JField createField(SyntheticArgumentBinding binding, JDeclaredType enclosingType, |
| Disposition disposition) { |
| JType type = getType(binding.type); |
| SourceInfo info = enclosingType.getSourceInfo().makeChild(); |
| JField field = |
| program.createField(info, String.valueOf(binding.name), enclosingType, type, false, |
| disposition); |
| info.addCorrelation(info.getCorrelator().by(field)); |
| if (binding.matchingField != null) { |
| typeMap.put(binding.matchingField, field); |
| } |
| typeMap.put(binding, field); |
| return field; |
| } |
| |
| private void createMethod(MethodBinding binding, SourceInfo info) { |
| JDeclaredType enclosingType = (JDeclaredType) getType(binding.declaringClass); |
| JMethod newMethod = processMethodBinding(binding, enclosingType, info); |
| mapParameters(newMethod, binding, info); |
| } |
| |
| private JParameter createParameter(LocalVariableBinding binding, JMethod enclosingMethod, |
| SourceInfo info) { |
| JType type = getType(binding.type); |
| JParameter param = |
| JProgram.createParameter(info, String.valueOf(binding.name), type, binding.isFinal(), |
| false, enclosingMethod); |
| typeMap.put(binding, param); |
| return param; |
| } |
| |
| private JParameter createParameter(SyntheticArgumentBinding arg, String argName, |
| JMethod enclosingMethod) { |
| JType type = getType(arg.type); |
| JParameter param = |
| JProgram.createParameter(enclosingMethod.getSourceInfo(), argName, type, true, false, |
| enclosingMethod); |
| return param; |
| } |
| |
| private JParameter createParameter(TypeBinding paramType, JMethod enclosingMethod, |
| SourceInfo info, int argPosition) { |
| JType type = getType(paramType); |
| // TODO(tobyr) Get the actual param name if it's present in debug info |
| // or otherwise. |
| String syntheticParamName = "arg" + argPosition; |
| JParameter param = |
| JProgram.createParameter(info, syntheticParamName, type, true, false, enclosingMethod); |
| // Don't need to put the parameter in the TypeMap as it won't be looked |
| // up for binary types. |
| return param; |
| } |
| |
| private TypeDeclaration[] createPeersForNonTypeDecls() { |
| // Traverse to create our JNode peers for each method, field, |
| // parameter, and local |
| BuildDeclMapVisitor v = new BuildDeclMapVisitor(); |
| for (CompilationUnitDeclaration unitDecl : unitDecls) { |
| unitDecl.traverse(v, unitDecl.scope); |
| } |
| return v.getTypeDeclarataions(); |
| } |
| |
| private void createPeersForUnits() { |
| // Traverse to create our JNode peers for each type |
| BuildTypeMapVisitor v = new BuildTypeMapVisitor(); |
| for (CompilationUnitDeclaration unitDecl : unitDecls) { |
| unitDecl.traverse(v, unitDecl.scope); |
| } |
| } |
| |
| private JDeclaredType createType(String name, SourceInfo info, ReferenceBinding binding) { |
| |
| JDeclaredType newType; |
| if (binding.isClass()) { |
| newType = program.createClass(info, name, binding.isAbstract(), binding.isFinal()); |
| } else if (binding.isInterface() || binding.isAnnotationType()) { |
| newType = program.createInterface(info, name); |
| } else if (binding.isEnum()) { |
| if (binding.isAnonymousType()) { |
| // Don't model an enum subclass as a JEnumType. |
| newType = program.createClass(info, name, false, true); |
| } else { |
| newType = program.createEnum(info, name, binding.isAbstract()); |
| } |
| } else { |
| throw new InternalCompilerException("ReferenceBinding is not a class, interface, or enum."); |
| } |
| |
| info.addCorrelation(info.getCorrelator().by(newType)); |
| |
| /** |
| * We emulate static initializers and instance initializers as methods. As |
| * in other cases, this gives us: simpler AST, easier to optimize, more like |
| * output JavaScript. Clinit is always in slot 0, init (if it exists) is |
| * always in slot 1. |
| */ |
| SourceInfo child = info.makeChild(); |
| JMethod clinit = |
| program.createMethod(child, "$clinit", newType, program.getTypeVoid(), false, true, true, |
| true, false); |
| clinit.freezeParamTypes(); |
| clinit.setSynthetic(); |
| child.addCorrelation(info.getCorrelator().by(clinit)); |
| |
| if (newType instanceof JClassType) { |
| child = info.makeChild(); |
| JMethod init = |
| program.createMethod(child, "$init", newType, program.getTypeVoid(), false, false, true, |
| true, false); |
| init.freezeParamTypes(); |
| init.setSynthetic(); |
| child.addCorrelation(info.getCorrelator().by(init)); |
| } |
| |
| newType.setExternal(linker.isExternalType(newType.getName())); |
| return newType; |
| } |
| |
| private void forEachExternalType(Map<String, BinaryTypeBinding> bindings, ExternalTypeTask task) { |
| for (Map.Entry<String, BinaryTypeBinding> entry : bindings.entrySet()) { |
| String klass = entry.getKey(); |
| if (linker.isExternalType(klass)) { |
| BinaryTypeBinding binding = bindings.get(klass); |
| if (binding != null) { |
| task.process(klass, binding); |
| } |
| } |
| } |
| } |
| |
| private JType getType(TypeBinding binding) { |
| JType type = (JType) typeMap.tryGet(binding); |
| |
| if (type != null) { |
| return type; |
| } |
| |
| if (binding instanceof ArrayBinding) { |
| binding = ((ArrayBinding) binding).leafComponentType; |
| } |
| |
| if (!(binding instanceof ReferenceBinding)) { |
| throw new InternalCompilerException("Expected a ReferenceBinding but received a " |
| + binding.getClass()); |
| } |
| |
| ReferenceBinding refBinding = (ReferenceBinding) binding; |
| String name = dotify(refBinding.compoundName); |
| if (!linker.isExternalType(name)) { |
| // typeMap.get() will fail with an appropriate exception |
| return (JType) typeMap.get(binding); |
| } |
| |
| type = createExternalType(name, refBinding); |
| resolve((JDeclaredType) type, refBinding); |
| return type; |
| } |
| |
| private void mapParameters(JMethod method, AbstractMethodDeclaration x, SourceInfo info) { |
| MethodBinding b = x.binding; |
| int paramCount = (b.parameters != null ? b.parameters.length : 0); |
| if (paramCount > 0) { |
| for (int i = 0, n = x.arguments.length; i < n; ++i) { |
| createParameter(x.arguments[i].binding, method, info); |
| } |
| } |
| method.freezeParamTypes(); |
| } |
| |
| private void mapParameters(JMethod method, MethodBinding binding, SourceInfo info) { |
| int paramCount = binding.parameters != null ? binding.parameters.length : 0; |
| if (paramCount > 0) { |
| int counter = 0; |
| for (TypeBinding argType : binding.parameters) { |
| createParameter(argType, method, info, counter++); |
| } |
| } |
| method.freezeParamTypes(); |
| } |
| |
| private boolean process(ReferenceBinding binding) { |
| JDeclaredType type = (JDeclaredType) getType(binding); |
| |
| try { |
| // Create an override for getClass(). |
| if (type instanceof JClassType && type != program.getTypeJavaLangObject()) { |
| |
| SourceInfo info = type.getSourceInfo().makeChild(); |
| JMethod getClassMethod = |
| program.createMethod(info, "getClass", type, program.getTypeJavaLangClass(), false, |
| false, false, false, false); |
| assert (type.getMethods().get(2) == getClassMethod); |
| getClassMethod.freezeParamTypes(); |
| getClassMethod.setSynthetic(); |
| info.addCorrelation(info.getCorrelator().by(getClassMethod)); |
| } |
| |
| if (binding.isNestedType() && !binding.isStatic() && !(binding instanceof BinaryTypeBinding)) { |
| // TODO(tobyr) Do something here for binary types? |
| |
| // add synthetic fields for outer this and locals |
| assert (type instanceof JClassType); |
| NestedTypeBinding nestedBinding = (NestedTypeBinding) binding; |
| if (nestedBinding.enclosingInstances != null) { |
| for (int i = 0; i < nestedBinding.enclosingInstances.length; ++i) { |
| SyntheticArgumentBinding arg = nestedBinding.enclosingInstances[i]; |
| createField(arg, type, Disposition.THIS_REF); |
| } |
| } |
| |
| if (nestedBinding.outerLocalVariables != null) { |
| for (int i = 0; i < nestedBinding.outerLocalVariables.length; ++i) { |
| SyntheticArgumentBinding arg = nestedBinding.outerLocalVariables[i]; |
| // See InnerClassTest.testOuterThisFromSuperCall(). |
| boolean isReallyThisRef = false; |
| if (arg.actualOuterLocalVariable instanceof SyntheticArgumentBinding) { |
| SyntheticArgumentBinding outer = |
| (SyntheticArgumentBinding) arg.actualOuterLocalVariable; |
| if (outer.matchingField != null) { |
| JField field = (JField) typeMap.get(outer.matchingField); |
| if (field.isThisRef()) { |
| isReallyThisRef = true; |
| } |
| } |
| } |
| createField(arg, type, isReallyThisRef ? Disposition.THIS_REF : Disposition.FINAL); |
| } |
| } |
| } |
| |
| ReferenceBinding superClassBinding = binding.superclass(); |
| if (type instanceof JClassType && superClassBinding != null) { |
| // TODO: handle separately? |
| assert (binding.superclass().isClass() || binding.superclass().isEnum()); |
| JClassType superClass = (JClassType) getType(superClassBinding); |
| ((JClassType) type).setSuperClass(superClass); |
| } |
| |
| ReferenceBinding[] superInterfaces = binding.superInterfaces(); |
| for (ReferenceBinding superInterfaceBinding : superInterfaces) { |
| assert (superInterfaceBinding.isInterface()); |
| JInterfaceType superInterface = (JInterfaceType) getType(superInterfaceBinding); |
| type.addImplements(superInterface); |
| } |
| |
| ReferenceBinding enclosingBinding = binding.enclosingType(); |
| if (enclosingBinding != null) { |
| type.setEnclosingType((JDeclaredType) getType(enclosingBinding)); |
| } |
| |
| if (type instanceof JEnumType) { |
| processEnumType(binding, (JEnumType) type); |
| } |
| |
| return true; |
| } catch (VirtualMachineError e) { |
| // Always rethrow VM errors (an attempt to wrap may fail). |
| throw e; |
| } catch (InternalCompilerException ice) { |
| ice.addNode(type); |
| throw ice; |
| } catch (Throwable e) { |
| throw new InternalCompilerException(type, "Error building type map", e); |
| } |
| } |
| |
| private JConstructor processConstructor(MethodBinding b, ConstructorDeclaration decl, |
| SourceInfo info) { |
| JClassType enclosingType = (JClassType) getType(b.declaringClass); |
| JConstructor newCtor = program.createConstructor(info, enclosingType); |
| |
| // Enums have hidden arguments for name and value |
| if (enclosingType.isEnumOrSubclass() != null) { |
| JProgram.createParameter(info, "enum$name", program.getTypeJavaLangString(), true, false, |
| newCtor); |
| JProgram.createParameter(info, "enum$ordinal", program.getTypePrimitiveInt(), true, false, |
| newCtor); |
| } |
| |
| ReferenceBinding declaringClass = b.declaringClass; |
| Set<String> alreadyNamedVariables = new HashSet<String>(); |
| if (declaringClass.isNestedType() && !declaringClass.isStatic()) { |
| // TODO(tobyr) Do we have to do the equivalent for binary types here |
| // or will this just fall out correctly? |
| |
| // add synthetic args for outer this |
| NestedTypeBinding nestedBinding = (NestedTypeBinding) declaringClass; |
| if (nestedBinding.enclosingInstances != null) { |
| for (int i = 0; i < nestedBinding.enclosingInstances.length; ++i) { |
| SyntheticArgumentBinding arg = nestedBinding.enclosingInstances[i]; |
| String argName = String.valueOf(arg.name); |
| if (alreadyNamedVariables.contains(argName)) { |
| argName += "_" + i; |
| } |
| createParameter(arg, argName, newCtor); |
| alreadyNamedVariables.add(argName); |
| } |
| } |
| } |
| |
| // user args |
| if (decl == null) { |
| mapParameters(newCtor, b, info); |
| } else { |
| mapParameters(newCtor, decl, info); |
| } |
| // original params are now frozen |
| |
| addThrownExceptions(b, newCtor); |
| |
| info.addCorrelation(info.getCorrelator().by(newCtor)); |
| |
| if (declaringClass.isNestedType() && !declaringClass.isStatic()) { |
| // add synthetic args for locals |
| NestedTypeBinding nestedBinding = (NestedTypeBinding) declaringClass; |
| // add synthetic args for outer this and locals |
| if (nestedBinding.outerLocalVariables != null) { |
| for (int i = 0; i < nestedBinding.outerLocalVariables.length; ++i) { |
| SyntheticArgumentBinding arg = nestedBinding.outerLocalVariables[i]; |
| String argName = String.valueOf(arg.name); |
| if (alreadyNamedVariables.contains(argName)) { |
| argName += "_" + i; |
| } |
| createParameter(arg, argName, newCtor); |
| alreadyNamedVariables.add(argName); |
| } |
| } |
| } |
| |
| if (enclosingType.isExternal()) { |
| newCtor.setBody(null); |
| } |
| |
| typeMap.put(b, newCtor); |
| return newCtor; |
| } |
| |
| private void processEnumType(ReferenceBinding binding, JEnumType type) { |
| // Visit the synthetic values() and valueOf() methods. |
| for (MethodBinding methodBinding : binding.methods()) { |
| if (methodBinding instanceof SyntheticMethodBinding) { |
| JMethod newMethod = processMethodBinding(methodBinding, type, type.getSourceInfo()); |
| TypeBinding[] parameters = methodBinding.parameters; |
| if (parameters.length == 0) { |
| assert newMethod.getName().equals("values"); |
| } else if (parameters.length == 1) { |
| assert newMethod.getName().equals("valueOf"); |
| assert typeMap.get(parameters[0]) == program.getTypeJavaLangString(); |
| JProgram.createParameter(newMethod.getSourceInfo(), "name", program |
| .getTypeJavaLangString(), true, false, newMethod); |
| } else { |
| assert false; |
| } |
| newMethod.freezeParamTypes(); |
| } |
| } |
| } |
| |
| private void processExternalMethod(MethodBinding binding, JDeclaredType type) { |
| if (binding.isPrivate() |
| || (type.getName().startsWith("java.") && !binding.isPublic() && !binding.isProtected())) { |
| return; |
| } |
| if (binding.isConstructor()) { |
| processConstructor(binding, null, type.getSourceInfo()); |
| } else { |
| createMethod(binding, type.getSourceInfo()); |
| } |
| } |
| |
| private JMethod processMethodBinding(MethodBinding b, JDeclaredType enclosingType, SourceInfo info) { |
| JType returnType = getType(b.returnType); |
| JMethod newMethod = |
| program.createMethod(info, String.valueOf(b.selector), enclosingType, returnType, b |
| .isAbstract(), b.isStatic(), b.isFinal(), b.isPrivate(), b.isNative()); |
| addThrownExceptions(b, newMethod); |
| if (b.isSynthetic()) { |
| newMethod.setSynthetic(); |
| } |
| |
| if (enclosingType.isExternal()) { |
| newMethod.setBody(null); |
| } |
| typeMap.put(b, newMethod); |
| return newMethod; |
| } |
| |
| private void resolve(JDeclaredType type, ReferenceBinding binding) { |
| process(binding); |
| |
| for (FieldBinding fieldBinding : binding.fields()) { |
| if (fieldBinding.isPrivate() |
| || (type.getName().startsWith("java.") && !fieldBinding.isPublic() && !fieldBinding |
| .isProtected())) { |
| continue; |
| } |
| |
| createField(type.getSourceInfo(), fieldBinding, type); |
| } |
| |
| for (MethodBinding methodBinding : binding.methods()) { |
| processExternalMethod(methodBinding, type); |
| } |
| |
| if (binding instanceof BinaryTypeBinding) { |
| // Unlike SourceTypeBindings, we have to explicitly ask for bridge methods |
| // for BinaryTypeBindings. |
| try { |
| // TODO(tobyr) Fix so we don't have to use reflection. |
| Method m = BinaryTypeBinding.class.getDeclaredMethod("bridgeMethods"); |
| MethodBinding[] bridgeMethods = (MethodBinding[]) m.invoke(binding); |
| |
| for (MethodBinding methodBinding : bridgeMethods) { |
| processExternalMethod(methodBinding, type); |
| } |
| } catch (Exception e) { |
| throw new InternalCompilerException("Unexpected failure", e); |
| } |
| } |
| } |
| |
| /** |
| * Creates and resolves all external types. |
| */ |
| private void resolveExternalTypes(Map<String, BinaryTypeBinding> bindings) { |
| forEachExternalType(bindings, new ExternalTypeCreator()); |
| forEachExternalType(bindings, new ExternalTypeResolver()); |
| } |
| } |
