Java tutorial
/* * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.flex.compiler.internal.abc; import java.util.Vector; import org.apache.flex.abc.ABCConstants; import org.apache.flex.abc.semantics.ClassInfo; import org.apache.flex.abc.semantics.MethodInfo; import org.apache.flex.abc.semantics.Name; import org.apache.flex.abc.semantics.Namespace; import org.apache.flex.abc.semantics.Nsset; import org.apache.flex.abc.semantics.PooledValue; import org.apache.flex.abc.semantics.Traits; import org.apache.flex.abc.visitors.ITraitVisitor; import org.apache.flex.abc.visitors.ITraitsVisitor; import org.apache.flex.compiler.constants.IASLanguageConstants; import org.apache.flex.compiler.definitions.IParameterDefinition; import org.apache.flex.compiler.definitions.references.INamespaceReference; import org.apache.flex.compiler.definitions.references.IReference; import org.apache.flex.compiler.definitions.references.ReferenceFactory; import org.apache.flex.compiler.internal.definitions.ClassDefinition; import org.apache.flex.compiler.internal.definitions.ConstantDefinition; import org.apache.flex.compiler.internal.definitions.DefinitionBase; import org.apache.flex.compiler.internal.definitions.FunctionDefinition; import org.apache.flex.compiler.internal.definitions.GetterDefinition; import org.apache.flex.compiler.internal.definitions.NamespaceDefinition; import org.apache.flex.compiler.internal.definitions.ParameterDefinition; import org.apache.flex.compiler.internal.definitions.SetterDefinition; import org.apache.flex.compiler.internal.definitions.TypeDefinitionBase; import org.apache.flex.compiler.internal.definitions.VariableDefinition; import org.apache.flex.compiler.internal.scopes.ASScope; import org.apache.flex.compiler.internal.scopes.FunctionScope; import org.apache.flex.compiler.scopes.IASScope; import com.google.common.base.Predicate; import com.google.common.collect.Iterables; /** * This {@link ITraitsVisitor} creates definition for each trait, and add the * definitions to a scope object. */ public class ScopedDefinitionTraitsVisitor implements ITraitsVisitor { private static final IReference TYPE_ANY = ReferenceFactory .builtinReference(IASLanguageConstants.BuiltinType.ANY_TYPE); private static final IReference TYPE_FUNCTION = ReferenceFactory .builtinReference(IASLanguageConstants.BuiltinType.FUNCTION); private final ASScope scope; private final boolean isStatic; private final ABCScopeBuilder scopeBuilder; private final INamespaceReference interfNamespace; public ScopedDefinitionTraitsVisitor(final ABCScopeBuilder owner, final IASScope scope, boolean isStatic) { this(owner, scope, isStatic, null); } public ScopedDefinitionTraitsVisitor(final ABCScopeBuilder owner, final IASScope scope, boolean isStatic, INamespaceReference interfNamespace) { assert scope instanceof ASScope; this.scopeBuilder = owner; this.scope = (ASScope) scope; this.isStatic = isStatic; this.interfNamespace = interfNamespace; } @Override public ITraitVisitor visitSlotTrait(int kind, Name name, int slot_id, Name slot_type, Object slot_value) { final String definitionName = getDefinitionName(name); final DefinitionBase def; kind &= ABCConstants.TRAIT_KIND_MASK; switch (kind) { case ABCConstants.KIND_SLOT: def = new VariableDefinition(definitionName, slot_value); break; case ABCConstants.KIND_CONST: if (slot_value instanceof Namespace) def = NamespaceDefinition.createNamespaceDefinition(definitionName, (Namespace) slot_value); else def = new ConstantDefinition(definitionName, slot_value); break; default: throw new IllegalStateException("Invalid slot kind: " + kind); } final INamespaceReference namespaceReference = getNamespaceReference(name); def.setNamespaceReference(namespaceReference); if (isStatic) def.setStatic(); def.setTypeReference(slot_type == null ? TYPE_ANY : scopeBuilder.getReference(slot_type)); scope.addDefinition(def); return new CollectMetadataTraitVisitor(def); } @Override public ITraitVisitor visitMethodTrait(int kind, Name name, int disp_id, MethodInfo method) { final String definitionName = getDefinitionName(name); FunctionDefinition methodDef; kind &= ABCConstants.TRAIT_KIND_MASK; switch (kind) { case ABCConstants.KIND_METHOD: methodDef = new FunctionDefinition(definitionName); break; case ABCConstants.KIND_GETTER: methodDef = new GetterDefinition(definitionName); break; case ABCConstants.KIND_SETTER: methodDef = new SetterDefinition(definitionName); break; case ABCConstants.KIND_FUNCTION: methodDef = new FunctionDefinition(definitionName); break; default: throw new IllegalStateException("Invalid method kind:" + kind); } final INamespaceReference namespaceReference = getNamespaceReference(name); methodDef.setNamespaceReference(namespaceReference); int paramTypesSize = method.getParamTypes().size(); final ParameterDefinition params[] = new ParameterDefinition[paramTypesSize + (method.needsRest() ? 1 : 0)]; if (params.length > 0) { ASScope methodScope = new FunctionScope(scope); methodScope.setContainingDefinition(methodDef); methodDef.setContainedScope(methodScope); Vector<PooledValue> defaultValues = method.getDefaultValues(); int firstOptionalParam = paramTypesSize - defaultValues.size(); for (int i = 0; i < paramTypesSize; i++) { final Name paramType = method.getParamTypes().get(i); final String paramName = i < method.getParamNames().size() ? method.getParamNames().get(i) : MethodInfo.UNKNOWN_PARAM_NAME; params[i] = new ParameterDefinition(paramName); params[i].setTypeReference(paramType == null ? TYPE_ANY : scopeBuilder.getReference(paramType)); if (i >= firstOptionalParam) { Object defaultValue = defaultValues.get(i - firstOptionalParam).getValue(); params[i].setDefaultValue(defaultValue); } methodScope.addDefinition(params[i]); } if (method.needsRest()) { ParameterDefinition rest = new ParameterDefinition(MethodInfo.UNKNOWN_PARAM_NAME); rest.setRest(); rest.setTypeReference(ReferenceFactory.builtinReference(IASLanguageConstants.BuiltinType.ARRAY)); params[paramTypesSize] = rest; } } methodDef.setParameters(params); Name returnType = method.getReturnType(); methodDef.setReturnTypeReference(returnType == null ? TYPE_ANY : scopeBuilder.getReference(returnType)); // The type of a getter or setter is its property type // (i.e., the getter's return type or the setter's parameter type). // The type of a method or function is "Function". switch (kind) { case ABCConstants.KIND_GETTER: methodDef.setTypeReference(methodDef.getReturnTypeReference()); break; case ABCConstants.KIND_SETTER: methodDef.setTypeReference(methodDef.getParameters()[0].getTypeReference()); break; case ABCConstants.KIND_METHOD: case ABCConstants.KIND_FUNCTION: methodDef.setTypeReference(TYPE_FUNCTION); break; default: throw new IllegalStateException("Invalid method kind:" + kind); } if (isStatic) methodDef.setStatic(); scope.addDefinition(methodDef); return new CollectMetadataTraitVisitor(methodDef); } @Override public ITraitVisitor visitClassTrait(int kind, Name name, int slot_id, ClassInfo clazz) { final TypeDefinitionBase classDef = scopeBuilder.classDefinitions.get(clazz); assert classDef != null : "Null class def at #" + slot_id; scope.addDefinition(classDef); classDef.getContainedScope().setContainingScope(scope); // Need to setup the scopes for the constructor and any params // here instead of ABCScopeBuilder, as we need to have a handle to the // class scope which isn't set until here. if (classDef instanceof ClassDefinition) { FunctionDefinition ctor = (FunctionDefinition) ((ClassDefinition) classDef).getConstructor(); classDef.getContainedScope().addDefinition(ctor); IParameterDefinition[] params = ctor.getParameters(); if (params.length > 0) { ASScope ctorScope = new FunctionScope(scope); ctorScope.setContainingDefinition(ctor); ctor.setContainedScope(ctorScope); for (IParameterDefinition param : params) { ctorScope.addDefinition(param); } } } return new CollectMetadataTraitVisitor(classDef); } private static boolean legalDefinitionNsset(Nsset nsSet) { if (nsSet == null) return false; if (nsSet.length() == 1) return true; return Iterables.all(nsSet, new Predicate<Namespace>() { @Override public boolean apply(Namespace ns) { return ns.getApiVersion() != ABCConstants.NO_API_VERSION; } }); } public static String getDefinitionName(Name name) { final String baseName = name.getBaseName(); // A definition can only ever have one namespace entry // otherwise it is an invalid SWC. Nsset nsSet = name.getQualifiers(); if (!legalDefinitionNsset(nsSet)) { throw new IllegalStateException("Definition " + baseName + " can have only one qualifier or all qualifiers should be versioned namespaces"); } return baseName; } private INamespaceReference getNamespaceReference(Name name) { final Namespace namespace = Iterables.getFirst(name.getQualifiers(), null); assert namespace != null; INamespaceReference namespaceReference = (INamespaceReference) scopeBuilder .getNamespaceReferenceForNamespace(namespace); // Interface Namespaces are encoded as regular user defined namespaces in the ABC, but internally // we want them to be InterfaceNamespaceDefinitions. If we come across a user defined namespace while // building the traits for an interface, and it matches the interface namespace, then use the interface // namespace instead so that other processing that relies on InterfaceNamespaceDefinitions works right. if (interfNamespace != null && interfNamespace.equals(namespaceReference)) namespaceReference = interfNamespace; return namespaceReference; } @Override public void visit() { } @Override public void visitEnd() { } @Override public Traits getTraits() { return null; } }