| Index: dart/compiler/java/com/google/dart/compiler/ast/ASTNodes.java
|
| diff --git a/dart/compiler/java/com/google/dart/compiler/ast/ASTNodes.java b/dart/compiler/java/com/google/dart/compiler/ast/ASTNodes.java
|
| deleted file mode 100644
|
| index 2e3b87f062b1bef0d5fecae391eac85820e85c70..0000000000000000000000000000000000000000
|
| --- a/dart/compiler/java/com/google/dart/compiler/ast/ASTNodes.java
|
| +++ /dev/null
|
| @@ -1,1448 +0,0 @@
|
| -/*
|
| - * Copyright (c) 2012, the Dart project authors.
|
| - *
|
| - * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
|
| - *
|
| - * 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.dart.compiler.ast;
|
| -
|
| -import com.google.common.collect.ImmutableList;
|
| -import com.google.common.collect.Lists;
|
| -import com.google.dart.compiler.common.SourceInfo;
|
| -import com.google.dart.compiler.parser.Token;
|
| -import com.google.dart.compiler.resolver.Element;
|
| -import com.google.dart.compiler.resolver.ElementKind;
|
| -import com.google.dart.compiler.resolver.FieldElement;
|
| -import com.google.dart.compiler.resolver.MethodElement;
|
| -import com.google.dart.compiler.resolver.VariableElement;
|
| -import com.google.dart.compiler.type.InterfaceType;
|
| -import com.google.dart.compiler.type.Type;
|
| -import com.google.dart.compiler.type.TypeKind;
|
| -
|
| -import java.util.Collections;
|
| -import java.util.List;
|
| -import java.util.concurrent.atomic.AtomicBoolean;
|
| -
|
| -/**
|
| - * Defines utility methods that operate on nodes in a Dart AST structure (instances of
|
| - * {@link DartNode} and its subclasses).
|
| - */
|
| -public class ASTNodes {
|
| -
|
| - /**
|
| - * @return <code>true</code> if given {@link DartNode} is part of static method, static field or
|
| - * top-level function.
|
| - */
|
| - public static boolean isStaticContext(DartNode node) {
|
| - while (node != null) {
|
| - DartNode parent = node.getParent();
|
| - if (node instanceof DartMethodDefinition) {
|
| - DartMethodDefinition method = (DartMethodDefinition) node;
|
| - if (method.getModifiers().isStatic()) {
|
| - return true;
|
| - }
|
| - return parent instanceof DartUnit;
|
| - }
|
| - if (node instanceof DartField) {
|
| - DartField field = (DartField) node;
|
| - if (field.getModifiers().isStatic()) {
|
| - return true;
|
| - }
|
| - return parent != null && parent.getParent() instanceof DartUnit;
|
| - }
|
| - node = parent;
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given {@link DartNode} is part of factory method.
|
| - */
|
| - public static boolean isFactoryContext(DartNode node) {
|
| - while (node != null) {
|
| - if (node instanceof DartMethodDefinition) {
|
| - DartMethodDefinition method = (DartMethodDefinition) node;
|
| - return method.getModifiers().isFactory();
|
| - }
|
| - node = node.getParent();
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given {@link DartNode} is part of static method or factory.
|
| - */
|
| - public static boolean isStaticOrFactoryContext(DartNode node) {
|
| - return isFactoryContext(node) || isStaticContext(node);
|
| - }
|
| -
|
| - /**
|
| - * Returns complete field access node for given field name.
|
| - *
|
| - * <pre>
|
| - * node = 1; => node
|
| - * obj.node = 1; => obj.node
|
| - * </pre>
|
| - *
|
| - * Note, that we don't check if given {@link DartNode} is actually field name.
|
| - */
|
| - public static DartNode getPropertyAccessNode(DartNode node) {
|
| - DartNode parent = node.getParent();
|
| - if (parent instanceof DartPropertyAccess && ((DartPropertyAccess) parent).getName() == node) {
|
| - return parent;
|
| - }
|
| - return node;
|
| - }
|
| -
|
| - public static List<DartNode> findDeepestCommonPath(List<DartNode> nodes) {
|
| - List<List<DartNode>> parents = Lists.newArrayList();
|
| - for (DartNode node : nodes) {
|
| - parents.add(getParents(node));
|
| - }
|
| - return getLongestListPrefix(parents);
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link DartNode} of given {@link Class} which is given {@link DartNode} itself, or
|
| - * one of its parents.
|
| - */
|
| - @SuppressWarnings("unchecked")
|
| - public static <E extends DartNode> E getAncestor(DartNode node, Class<E> enclosingClass) {
|
| - while (node != null && !enclosingClass.isInstance(node)) {
|
| - node = node.getParent();
|
| - };
|
| - return (E) node;
|
| - }
|
| -
|
| - /**
|
| - * Get the element associated with the given AST node.
|
| - *
|
| - * @param node the target node
|
| - * @param includeDeclarations <code>true</code> if elements should be returned for declaration
|
| - * sites as well as for reference sites
|
| - * @return the associated element (or <code>null</code> if none can be found)
|
| - */
|
| - public static Element getElement(DartNode node, boolean includeDeclarations) {
|
| - Element targetElement = node.getElement();
|
| - DartNode parent = node.getParent();
|
| - // name of named parameter in invocation
|
| - if (node instanceof DartIdentifier && node.getParent() instanceof DartNamedExpression) {
|
| - DartNamedExpression namedExpression = (DartNamedExpression) node.getParent();
|
| - if (namedExpression.getName() == node) {
|
| - Object parameterId = ((DartIdentifier) node).getInvocationParameterId();
|
| - if (parameterId instanceof VariableElement) {
|
| - targetElement = (VariableElement) parameterId;
|
| - }
|
| - }
|
| - }
|
| - // target of "new X()" or "new X.a()" is not just a type, it is a constructor
|
| - if (parent instanceof DartTypeNode || parent instanceof DartPropertyAccess) {
|
| - DartNode grandparent = parent.getParent();
|
| - if (grandparent instanceof DartNewExpression) {
|
| - targetElement = ((DartNewExpression) grandparent).getElement();
|
| - }
|
| - } else if (parent instanceof DartRedirectConstructorInvocation
|
| - || parent instanceof DartSuperConstructorInvocation) {
|
| - targetElement = parent.getElement();
|
| - }
|
| - return targetElement;
|
| - }
|
| -
|
| - /**
|
| - * Return the class definition enclosing the given node, or <code>null</code> if the node is not a
|
| - * child of a class definition.
|
| - *
|
| - * @param node the node enclosed in the class definition to be returned
|
| - * @return the class definition enclosing the given node
|
| - */
|
| - public static DartClass getEnclosingDartClass(DartNode node) {
|
| - return getEnclosingNodeOfType(DartClass.class, node);
|
| - }
|
| -
|
| - /**
|
| - * Return the first node of the given class that encloses the given node, or <code>null</code> if
|
| - * the node is not a child of a node of the given class. The node itself will <b>not</b> be
|
| - * returned, even if it is an instance of the given class.
|
| - *
|
| - * @param enclosingNodeClass the class of node to be returned
|
| - * @param node the child of the node to be returned
|
| - * @return the specified parent of the given node
|
| - */
|
| - @SuppressWarnings("unchecked")
|
| - public static <E extends DartNode> E getEnclosingNodeOfType(Class<E> enclosingNodeClass,
|
| - DartNode node) {
|
| - DartNode parent = node.getParent();
|
| - while (parent != null && !enclosingNodeClass.isInstance(parent)) {
|
| - parent = parent.getParent();
|
| - }
|
| - return (E) parent;
|
| - }
|
| -
|
| - public static int getExclusiveEnd(DartNode node) {
|
| - SourceInfo sourceInfo = node.getSourceInfo();
|
| - return sourceInfo.getOffset() + sourceInfo.getLength();
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link FieldElement} with {@link ElementKind#VARIABLE} if the given
|
| - * {@link DartIdentifier} is the field reference, or <code>null</code> in the other case.
|
| - */
|
| - public static FieldElement getFieldElement(DartIdentifier node) {
|
| - Element element = node.getElement();
|
| - if (ElementKind.of(element) == ElementKind.FIELD) {
|
| - return (FieldElement) element;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - public static int getInclusiveEnd(DartNode node) {
|
| - SourceInfo sourceInfo = node.getSourceInfo();
|
| - return sourceInfo.getOffset() + sourceInfo.getLength() - 1;
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link DartExpression} qualified if given node is name part of
|
| - * {@link DartPropertyAccess}. May be <code>null</code>.
|
| - */
|
| - public static DartNode getNodeQualifier(DartIdentifier node) {
|
| - if (node.getParent() instanceof DartPropertyAccess) {
|
| - DartPropertyAccess propertyAccess = (DartPropertyAccess) node.getParent();
|
| - if (propertyAccess.getName() == node) {
|
| - return propertyAccess.getQualifier();
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link VariableElement} if the given {@link DartIdentifier} is the parameter
|
| - * reference, or <code>null</code> in the other case.
|
| - */
|
| - public static VariableElement getParameterElement(DartIdentifier node) {
|
| - Element element = node.getElement();
|
| - if (ElementKind.of(element) == ElementKind.PARAMETER) {
|
| - return (VariableElement) element;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return the index of given {@link VariableElement} in parameters, or <code>-1</code> if not
|
| - * parameter.
|
| - */
|
| - public static int getParameterIndex(VariableElement variableElement) {
|
| - Element enclosingElement = variableElement.getEnclosingElement();
|
| - if (enclosingElement instanceof MethodElement) {
|
| - MethodElement methodElement = (MethodElement) enclosingElement;
|
| - return methodElement.getParameters().indexOf(variableElement);
|
| - }
|
| - return -1;
|
| - }
|
| -
|
| - /**
|
| - * Returns the closest ancestor of <code>node</code> that is an instance of
|
| - * <code>parentClass</code>, or <code>null</code> if none.
|
| - * <p>
|
| - * <b>Warning:</b> This method does not stop at any boundaries like parentheses, statements, body
|
| - * declarations, etc. The resulting node may be in a totally different scope than the given node.
|
| - * Consider using one of the {@link ASTResolving}<code>.find(..)</code> methods instead.
|
| - * </p>
|
| - *
|
| - * @param node the node
|
| - * @param parentClass the class of the sought ancestor node
|
| - * @return the closest ancestor of <code>node</code> that is an instance of
|
| - * <code>parentClass</code>, or <code>null</code> if none
|
| - */
|
| - @SuppressWarnings("unchecked")
|
| - public static <E extends DartNode> E getParent(DartNode node, Class<E> parentClass) {
|
| - do {
|
| - node = node.getParent();
|
| - } while (node != null && !parentClass.isInstance(node));
|
| - return (E) node;
|
| - }
|
| -
|
| -// private static class ChildrenCollector extends ASTVisitor<Void> {
|
| -// public List<DartNode> result;
|
| -//
|
| -// @Override
|
| -// public Void visitNode(DartNode node) {
|
| -// // first visitNode: on the node's parent: do nothing, return true
|
| -// if (result == null) {
|
| -// result = Lists.newArrayList();
|
| -// return super.visitNode(node);
|
| -// } else {
|
| -// result.add(node);
|
| -// }
|
| -// }
|
| -// }
|
| -//
|
| -// public static final int NODE_ONLY = 0;
|
| -// public static final int INCLUDE_FIRST_PARENT = 1;
|
| -//
|
| -// public static final int INCLUDE_ALL_PARENTS = 2;
|
| -// public static final int WARNING = 1 << 0;
|
| -// public static final int ERROR = 1 << 1;
|
| -//
|
| -// public static final int PROBLEMS = WARNING | ERROR;
|
| -// private static final Message[] EMPTY_MESSAGES = new Message[0];
|
| -//
|
| -// private static final IProblem[] EMPTY_PROBLEMS = new IProblem[0];
|
| -//
|
| -// private static final int CLEAR_VISIBILITY =
|
| -// ~(Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE);
|
| -//
|
| -// public static String asFormattedString(DartNode node,
|
| -// int indent,
|
| -// String lineDelim,
|
| -// Map<String, String> options) {
|
| -// String unformatted = asString(node);
|
| -// TextEdit edit = CodeFormatterUtil.format2(node, unformatted, indent, lineDelim, options);
|
| -// if (edit != null) {
|
| -// Document document = new Document(unformatted);
|
| -// try {
|
| -// edit.apply(document, TextEdit.NONE);
|
| -// } catch (BadLocationException e) {
|
| -// JavaPlugin.log(e);
|
| -// }
|
| -// return document.get();
|
| -// }
|
| -// return unformatted; // unknown node
|
| -// }
|
| -//
|
| -// public static String asString(DartNode node) {
|
| -// ASTFlattener flattener = new ASTFlattener();
|
| -// node.accept(flattener);
|
| -// return flattener.getResult();
|
| -// }
|
| -//
|
| -// public static int changeVisibility(int modifiers, int visibility) {
|
| -// return modifiers & CLEAR_VISIBILITY | visibility;
|
| -// }
|
| -//
|
| -// public static InfixExpression.Operator convertToInfixOperator(Assignment.Operator operator) {
|
| -// if (operator.equals(Assignment.Operator.PLUS_ASSIGN)) {
|
| -// return InfixExpression.Operator.PLUS;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.MINUS_ASSIGN)) {
|
| -// return InfixExpression.Operator.MINUS;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.TIMES_ASSIGN)) {
|
| -// return InfixExpression.Operator.TIMES;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.DIVIDE_ASSIGN)) {
|
| -// return InfixExpression.Operator.DIVIDE;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.BIT_AND_ASSIGN)) {
|
| -// return InfixExpression.Operator.AND;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.BIT_OR_ASSIGN)) {
|
| -// return InfixExpression.Operator.OR;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.BIT_XOR_ASSIGN)) {
|
| -// return InfixExpression.Operator.XOR;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.REMAINDER_ASSIGN)) {
|
| -// return InfixExpression.Operator.REMAINDER;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.LEFT_SHIFT_ASSIGN)) {
|
| -// return InfixExpression.Operator.LEFT_SHIFT;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.RIGHT_SHIFT_SIGNED_ASSIGN)) {
|
| -// return InfixExpression.Operator.RIGHT_SHIFT_SIGNED;
|
| -// }
|
| -//
|
| -// if (operator.equals(Assignment.Operator.RIGHT_SHIFT_UNSIGNED_ASSIGN)) {
|
| -// return InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED;
|
| -// }
|
| -//
|
| -// Assert.isTrue(false, "Cannot convert assignment operator"); //$NON-NLS-1$
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static DartNode findDeclaration(IBinding binding, DartNode root) {
|
| -// root = root.getRoot();
|
| -// if (root instanceof CompilationUnit) {
|
| -// return ((CompilationUnit) root).findDeclaringNode(binding);
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static Modifier findModifierNode(int flag, List<IExtendedModifier> modifiers) {
|
| -// for (int i = 0; i < modifiers.size(); i++) {
|
| -// Object curr = modifiers.get(i);
|
| -// if (curr instanceof Modifier && ((Modifier) curr).getKeyword().toFlagValue() == flag) {
|
| -// return (Modifier) curr;
|
| -// }
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static DartNode findParent(DartNode node, StructuralPropertyDescriptor[][] pathes) {
|
| -// for (int p = 0; p < pathes.length; p++) {
|
| -// StructuralPropertyDescriptor[] path = pathes[p];
|
| -// DartNode current = node;
|
| -// int d = path.length - 1;
|
| -// for (; d >= 0 && current != null; d--) {
|
| -// StructuralPropertyDescriptor descriptor = path[d];
|
| -// if (!descriptor.equals(current.getLocationInParent())) {
|
| -// break;
|
| -// }
|
| -// current = current.getParent();
|
| -// }
|
| -// if (d < 0) {
|
| -// return current;
|
| -// }
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static VariableDeclaration findVariableDeclaration(IVariableBinding binding, DartNode root) {
|
| -// if (binding.isField()) {
|
| -// return null;
|
| -// }
|
| -// DartNode result = findDeclaration(binding, root);
|
| -// if (result instanceof VariableDeclaration) {
|
| -// return (VariableDeclaration) result;
|
| -// }
|
| -//
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static List<BodyDeclaration> getBodyDeclarations(DartNode node) {
|
| -// if (node instanceof AbstractTypeDeclaration) {
|
| -// return ((AbstractTypeDeclaration) node).bodyDeclarations();
|
| -// } else if (node instanceof AnonymousClassDeclaration) {
|
| -// return ((AnonymousClassDeclaration) node).bodyDeclarations();
|
| -// }
|
| -// // should not happen.
|
| -// Assert.isTrue(false);
|
| -// return null;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns the structural property descriptor for the "bodyDeclarations" property of this node
|
| -// * (element type: {@link BodyDeclaration}).
|
| -// *
|
| -// * @param node the node, either an {@link AbstractTypeDeclaration} or an
|
| -// * {@link AnonymousClassDeclaration}
|
| -// * @return the property descriptor
|
| -// */
|
| -// public static ChildListPropertyDescriptor getBodyDeclarationsProperty(DartNode node) {
|
| -// if (node instanceof AbstractTypeDeclaration) {
|
| -// return ((AbstractTypeDeclaration) node).getBodyDeclarationsProperty();
|
| -// } else if (node instanceof AnonymousClassDeclaration) {
|
| -// return AnonymousClassDeclaration.BODY_DECLARATIONS_PROPERTY;
|
| -// }
|
| -// // should not happen.
|
| -// Assert.isTrue(false);
|
| -// return null;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns a list of the direct children of a node. The siblings are ordered by start offset.
|
| -// *
|
| -// * @param node the node to get the children for
|
| -// * @return the children
|
| -// */
|
| -// public static List<DartNode> getChildren(DartNode node) {
|
| -// ChildrenCollector visitor = new ChildrenCollector();
|
| -// node.accept(visitor);
|
| -// return visitor.result;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns the list that contains the given DartNode. If the node isn't part of any list,
|
| -// * <code>null</code> is returned.
|
| -// *
|
| -// * @param node the node in question
|
| -// * @return the list that contains the node or <code>null</code>
|
| -// */
|
| -// public static List<? extends DartNode> getContainingList(DartNode node) {
|
| -// StructuralPropertyDescriptor locationInParent = node.getLocationInParent();
|
| -// if (locationInParent != null && locationInParent.isChildListProperty()) {
|
| -// return (List<? extends DartNode>) node.getParent().getStructuralProperty(locationInParent);
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static int getDimensions(VariableDeclaration declaration) {
|
| -// int dim = declaration.getExtraDimensions();
|
| -// Type type = getType(declaration);
|
| -// if (type instanceof ArrayType) {
|
| -// dim += ((ArrayType) type).getDimensions();
|
| -// }
|
| -// return dim;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns the element type. This is a convenience method that returns its argument if it is a
|
| -// * simple type and the element type if the parameter is an array type.
|
| -// *
|
| -// * @param type The type to get the element type from.
|
| -// * @return The element type of the type or the type itself.
|
| -// */
|
| -// public static Type getElementType(Type type) {
|
| -// if (!type.isArrayType()) {
|
| -// return type;
|
| -// }
|
| -// return ((ArrayType) type).getElementType();
|
| -// }
|
| -//
|
| -// public static ITypeBinding getEnclosingType(DartNode node) {
|
| -// while (node != null) {
|
| -// if (node instanceof AbstractTypeDeclaration) {
|
| -// return ((AbstractTypeDeclaration) node).resolveBinding();
|
| -// } else if (node instanceof AnonymousClassDeclaration) {
|
| -// return ((AnonymousClassDeclaration) node).resolveBinding();
|
| -// }
|
| -// node = node.getParent();
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static int getExclusiveEnd(DartNode node) {
|
| -// return node.getStartPosition() + node.getLength();
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns the type to which an inlined variable initializer should be cast, or <code>null</code>
|
| -// * if no cast is necessary.
|
| -// *
|
| -// * @param initializer the initializer expression of the variable to inline
|
| -// * @param reference the reference to the variable (which is to be inlined)
|
| -// * @return a type binding to which the initializer should be cast, or <code>null</code> iff no
|
| -// * cast is necessary
|
| -// */
|
| -// public static ITypeBinding getExplicitCast(Expression initializer, Expression reference) {
|
| -// ITypeBinding initializerType = initializer.resolveTypeBinding();
|
| -// ITypeBinding referenceType = reference.resolveTypeBinding();
|
| -// if (initializerType == null || referenceType == null) {
|
| -// return null;
|
| -// }
|
| -//
|
| -// if (initializerType.isPrimitive()
|
| -// && referenceType.isPrimitive()
|
| -// && !referenceType.isEqualTo(initializerType)) {
|
| -// return referenceType;
|
| -//
|
| -// } else if (initializerType.isPrimitive() && !referenceType.isPrimitive()) { // initializer is autoboxed
|
| -// ITypeBinding unboxedReferenceType =
|
| -// Bindings.getUnboxedTypeBinding(referenceType, reference.getAST());
|
| -// if (!unboxedReferenceType.isEqualTo(initializerType)) {
|
| -// return unboxedReferenceType;
|
| -// } else if (needsExplicitBoxing(reference)) {
|
| -// return referenceType;
|
| -// }
|
| -//
|
| -// } else if (!initializerType.isPrimitive() && referenceType.isPrimitive()) { // initializer is autounboxed
|
| -// ITypeBinding unboxedInitializerType =
|
| -// Bindings.getUnboxedTypeBinding(initializerType, reference.getAST());
|
| -// if (!unboxedInitializerType.isEqualTo(referenceType)) {
|
| -// return referenceType;
|
| -// }
|
| -//
|
| -// } else if (initializerType.isRawType() && referenceType.isParameterizedType()) {
|
| -// return referenceType; // don't lose the unchecked conversion
|
| -//
|
| -// } else if (!TypeRules.canAssign(initializerType, referenceType)) {
|
| -// if (!Bindings.containsTypeVariables(referenceType)) {
|
| -// return referenceType;
|
| -// }
|
| -// }
|
| -//
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static IVariableBinding getFieldBinding(Name node) {
|
| -// IVariableBinding result = getVariableBinding(node);
|
| -// if (result == null || !result.isField()) {
|
| -// return null;
|
| -// }
|
| -//
|
| -// return result;
|
| -// }
|
| -//
|
| -// public static int getInclusiveEnd(DartNode node) {
|
| -// return node.getStartPosition() + node.getLength() - 1;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Computes the insertion index to be used to add the given member to the the list
|
| -// * <code>container</code>.
|
| -// *
|
| -// * @param member the member to add
|
| -// * @param container a list containing objects of type <code>BodyDeclaration</code>
|
| -// * @return the insertion index to be used
|
| -// */
|
| -// public static int getInsertionIndex(BodyDeclaration member,
|
| -// List<? extends BodyDeclaration> container) {
|
| -// int containerSize = container.size();
|
| -//
|
| -// MembersOrderPreferenceCache orderStore =
|
| -// JavaPlugin.getDefault().getMemberOrderPreferenceCache();
|
| -//
|
| -// int orderIndex = getOrderPreference(member, orderStore);
|
| -//
|
| -// int insertPos = containerSize;
|
| -// int insertPosOrderIndex = -1;
|
| -//
|
| -// for (int i = containerSize - 1; i >= 0; i--) {
|
| -// int currOrderIndex = getOrderPreference(container.get(i), orderStore);
|
| -// if (orderIndex == currOrderIndex) {
|
| -// if (insertPosOrderIndex != orderIndex) { // no perfect match yet
|
| -// insertPos = i + 1; // after a same kind
|
| -// insertPosOrderIndex = orderIndex; // perfect match
|
| -// }
|
| -// } else if (insertPosOrderIndex != orderIndex) { // not yet a perfect match
|
| -// if (currOrderIndex < orderIndex) { // we are bigger
|
| -// if (insertPosOrderIndex == -1) {
|
| -// insertPos = i + 1; // after
|
| -// insertPosOrderIndex = currOrderIndex;
|
| -// }
|
| -// } else {
|
| -// insertPos = i; // before
|
| -// insertPosOrderIndex = currOrderIndex;
|
| -// }
|
| -// }
|
| -// }
|
| -// return insertPos;
|
| -// }
|
| -//
|
| -// public static SimpleName getLeftMostSimpleName(Name name) {
|
| -// if (name instanceof SimpleName) {
|
| -// return (SimpleName) name;
|
| -// } else {
|
| -// final SimpleName[] result = new SimpleName[1];
|
| -// ASTVisitor visitor = new ASTVisitor() {
|
| -// @Override
|
| -// public boolean visit(QualifiedName qualifiedName) {
|
| -// Name left = qualifiedName.getQualifier();
|
| -// if (left instanceof SimpleName) {
|
| -// result[0] = (SimpleName) left;
|
| -// } else {
|
| -// left.accept(this);
|
| -// }
|
| -// return false;
|
| -// }
|
| -// };
|
| -// name.accept(visitor);
|
| -// return result[0];
|
| -// }
|
| -// }
|
| -//
|
| -// public static SimpleType getLeftMostSimpleType(QualifiedType type) {
|
| -// final SimpleType[] result = new SimpleType[1];
|
| -// ASTVisitor visitor = new ASTVisitor() {
|
| -// @Override
|
| -// public boolean visit(QualifiedType qualifiedType) {
|
| -// Type left = qualifiedType.getQualifier();
|
| -// if (left instanceof SimpleType) {
|
| -// result[0] = (SimpleType) left;
|
| -// } else {
|
| -// left.accept(this);
|
| -// }
|
| -// return false;
|
| -// }
|
| -// };
|
| -// type.accept(visitor);
|
| -// return result[0];
|
| -// }
|
| -//
|
| -// public static IVariableBinding getLocalVariableBinding(Name node) {
|
| -// IVariableBinding result = getVariableBinding(node);
|
| -// if (result == null || result.isField()) {
|
| -// return null;
|
| -// }
|
| -//
|
| -// return result;
|
| -// }
|
| -//
|
| -// public static Message[] getMessages(DartNode node, int flags) {
|
| -// DartNode root = node.getRoot();
|
| -// if (!(root instanceof CompilationUnit)) {
|
| -// return EMPTY_MESSAGES;
|
| -// }
|
| -// Message[] messages = ((CompilationUnit) root).getMessages();
|
| -// if (root == node) {
|
| -// return messages;
|
| -// }
|
| -// final int iterations = computeIterations(flags);
|
| -// List<Message> result = new ArrayList<Message>(5);
|
| -// for (int i = 0; i < messages.length; i++) {
|
| -// Message message = messages[i];
|
| -// DartNode temp = node;
|
| -// int count = iterations;
|
| -// do {
|
| -// int nodeOffset = temp.getStartPosition();
|
| -// int messageOffset = message.getStartPosition();
|
| -// if (nodeOffset <= messageOffset && messageOffset < nodeOffset + temp.getLength()) {
|
| -// result.add(message);
|
| -// count = 0;
|
| -// } else {
|
| -// count--;
|
| -// }
|
| -// } while ((temp = temp.getParent()) != null && count > 0);
|
| -// }
|
| -// return result.toArray(new Message[result.size()]);
|
| -// }
|
| -//
|
| -// public static IMethodBinding getMethodBinding(Name node) {
|
| -// IBinding binding = node.resolveBinding();
|
| -// if (binding instanceof IMethodBinding) {
|
| -// return (IMethodBinding) binding;
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static List<IExtendedModifier> getModifiers(VariableDeclaration declaration) {
|
| -// Assert.isNotNull(declaration);
|
| -// if (declaration instanceof SingleVariableDeclaration) {
|
| -// return ((SingleVariableDeclaration) declaration).modifiers();
|
| -// } else if (declaration instanceof VariableDeclarationFragment) {
|
| -// DartNode parent = declaration.getParent();
|
| -// if (parent instanceof VariableDeclarationExpression) {
|
| -// return ((VariableDeclarationExpression) parent).modifiers();
|
| -// } else if (parent instanceof VariableDeclarationStatement) {
|
| -// return ((VariableDeclarationStatement) parent).modifiers();
|
| -// }
|
| -// }
|
| -// return new ArrayList<IExtendedModifier>(0);
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns the source of the given node from the location where it was parsed.
|
| -// *
|
| -// * @param node the node to get the source from
|
| -// * @param extendedRange if set, the extended ranges of the nodes should ne used
|
| -// * @param removeIndent if set, the indentation is removed.
|
| -// * @return return the source for the given node or null if accessing the source failed.
|
| -// */
|
| -// public static String getNodeSource(DartNode node, boolean extendedRange, boolean removeIndent) {
|
| -// DartNode root = node.getRoot();
|
| -// if (root instanceof CompilationUnit) {
|
| -// CompilationUnit astRoot = (CompilationUnit) root;
|
| -// ITypeRoot typeRoot = astRoot.getTypeRoot();
|
| -// try {
|
| -// if (typeRoot != null && typeRoot.getBuffer() != null) {
|
| -// IBuffer buffer = typeRoot.getBuffer();
|
| -// int offset =
|
| -// extendedRange ? astRoot.getExtendedStartPosition(node) : node.getStartPosition();
|
| -// int length = extendedRange ? astRoot.getExtendedLength(node) : node.getLength();
|
| -// String str = buffer.getText(offset, length);
|
| -// if (removeIndent) {
|
| -// IJavaProject project = typeRoot.getJavaProject();
|
| -// int indent = StubUtility.getIndentUsed(buffer, node.getStartPosition(), project);
|
| -// str =
|
| -// Strings.changeIndent(
|
| -// str,
|
| -// indent,
|
| -// project,
|
| -// new String(),
|
| -// typeRoot.findRecommendedLineSeparator());
|
| -// }
|
| -// return str;
|
| -// }
|
| -// } catch (JavaModelException e) {
|
| -// // ignore
|
| -// }
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static DartNode getNormalizedNode(DartNode node) {
|
| -// DartNode current = node;
|
| -// // normalize name
|
| -// if (QualifiedName.NAME_PROPERTY.equals(current.getLocationInParent())) {
|
| -// current = current.getParent();
|
| -// }
|
| -// // normalize type
|
| -// if (QualifiedType.NAME_PROPERTY.equals(current.getLocationInParent())
|
| -// || SimpleType.NAME_PROPERTY.equals(current.getLocationInParent())) {
|
| -// current = current.getParent();
|
| -// }
|
| -// // normalize parameterized types
|
| -// if (ParameterizedType.TYPE_PROPERTY.equals(current.getLocationInParent())) {
|
| -// current = current.getParent();
|
| -// }
|
| -// return current;
|
| -// }
|
| -
|
| - /**
|
| - * @return parent {@link DartNode}s from {@link DartUnit} (at index "0") to the given one.
|
| - */
|
| - public static List<DartNode> getParents(DartNode node) {
|
| - List<DartNode> parents = Lists.newArrayList();
|
| - DartNode current = node;
|
| - do {
|
| - parents.add(current.getParent());
|
| - current = current.getParent();
|
| - } while (current.getParent() != null);
|
| - Collections.reverse(parents);
|
| - return parents;
|
| - }
|
| -
|
| - /**
|
| - * @return given {@link DartStatement} if not {@link DartBlock}, first child {@link DartStatement}
|
| - * if {@link DartBlock}, or <code>null</code> if more than one child.
|
| - */
|
| - public static DartStatement getSingleStatement(DartStatement statement) {
|
| - if (statement instanceof DartBlock) {
|
| - List<DartStatement> blockStatements = ((DartBlock) statement).getStatements();
|
| - if (blockStatements.size() != 1) {
|
| - return null;
|
| - }
|
| - return blockStatements.get(0);
|
| - }
|
| - return statement;
|
| - }
|
| -
|
| - /**
|
| - * @return given {@link DartStatement} if not {@link DartBlock}, all children
|
| - * {@link DartStatement}s if {@link DartBlock}.
|
| - */
|
| - public static List<DartStatement> getStatements(DartStatement statement) {
|
| - if (statement instanceof DartBlock) {
|
| - return ((DartBlock) statement).getStatements();
|
| - }
|
| - return ImmutableList.of(statement);
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link DartThisExpression} if given node is name of {@link DartPropertyAccess} with
|
| - * {@link DartThisExpression} qualifier. May be <code>null</code>.
|
| - */
|
| - public static DartThisExpression getThisQualifier(DartIdentifier node) {
|
| - if (node.getParent() instanceof DartPropertyAccess) {
|
| - DartPropertyAccess propertyAccess = (DartPropertyAccess) node.getParent();
|
| - if (propertyAccess.getName() == node
|
| - && propertyAccess.getQualifier() instanceof DartThisExpression) {
|
| - return (DartThisExpression) propertyAccess.getQualifier();
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Return the type associated with the given type node, or <code>null</code> if the type could not
|
| - * be determined.
|
| - *
|
| - * @param typeNode the type node whose type is to be returned
|
| - * @return the type associated with the given type node
|
| - */
|
| - public static Type getType(DartTypeNode typeNode) {
|
| - Type type = typeNode.getType();
|
| - if (type == null) {
|
| - DartNode parent = typeNode.getParent();
|
| - if (parent instanceof DartTypeNode) {
|
| - Type parentType = getType((DartTypeNode) parent);
|
| - if (parentType != null && parentType.getKind() == TypeKind.INTERFACE) {
|
| - int index = ((DartTypeNode) parent).getTypeArguments().indexOf(typeNode);
|
| - return ((InterfaceType) parentType).getArguments().get(index);
|
| - }
|
| - }
|
| - }
|
| - return type;
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link VariableElement} with {@link ElementKind#VARIABLE} if the given
|
| - * {@link DartIdentifier} is the local variable reference, or <code>null</code> in the
|
| - * other case.
|
| - */
|
| - public static VariableElement getVariableElement(DartIdentifier node) {
|
| - Element element = node.getElement();
|
| - if (ElementKind.of(element) == ElementKind.VARIABLE) {
|
| - return (VariableElement) element;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link VariableElement} with {@link ElementKind#VARIABLE} or
|
| - * {@link ElementKind#PARAMETER} if the given {@link DartIdentifier} is the reference to
|
| - * local variable or parameter, or <code>null</code> in the other case.
|
| - */
|
| - public static VariableElement getVariableOrParameterElement(DartIdentifier node) {
|
| - Element element = node.getElement();
|
| - if (element instanceof VariableElement) {
|
| - return (VariableElement) element;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Return <code>true</code> if the given method is a constructor.
|
| - *
|
| - * @param method the method being tested
|
| - * @return <code>true</code> if the given method is a constructor
|
| - */
|
| - public static boolean isConstructor(DartMethodDefinition method) {
|
| - MethodElement methodElement = method.getElement();
|
| - if (methodElement != null) {
|
| - return methodElement.isConstructor();
|
| - }
|
| - return isConstructor(((DartClass) method.getParent()).getClassName(), method);
|
| - }
|
| -
|
| - /**
|
| - * Return <code>true</code> if the given method is a constructor.
|
| - *
|
| - * @param className the name of the type containing the method definition
|
| - * @param method the method being tested
|
| - * @return <code>true</code> if the given method is a constructor
|
| - */
|
| - public static boolean isConstructor(String className, DartMethodDefinition method) {
|
| - if (method.getModifiers().isFactory()) {
|
| - return true;
|
| - }
|
| - DartExpression name = method.getName();
|
| - if (name instanceof DartIdentifier) {
|
| - return ((DartIdentifier) name).getName().equals(className);
|
| - } else if (name instanceof DartPropertyAccess) {
|
| - DartPropertyAccess property = (DartPropertyAccess) name;
|
| - DartNode qualifier = property.getQualifier();
|
| - if (qualifier instanceof DartIdentifier) {
|
| - return ((DartIdentifier) qualifier).getName().equals(className);
|
| - }
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given {@link DartNode} is the name of some {@link DartDeclaration}
|
| - * .
|
| - */
|
| - public static boolean isNameOfDeclaration(DartNode node) {
|
| - return node.getParent() instanceof DartDeclaration<?>
|
| - && ((DartDeclaration<?>) node.getParent()).getName() == node;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given {@link List}s are equals at given position.
|
| - */
|
| - private static <T> boolean allListsEqual(List<List<T>> lists, int position) {
|
| - T element = lists.get(0).get(position);
|
| - for (List<T> list : lists) {
|
| - if (list.get(position) != element) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - private static <T> List<T> getLongestListPrefix(List<List<T>> lists) {
|
| - if (lists.isEmpty()) {
|
| - return ImmutableList.of();
|
| - }
|
| - // prepare minimal length of all arrays
|
| - int minLength = lists.get(0).size();
|
| - for (List<T> list : lists) {
|
| - minLength = Math.min(minLength, list.size());
|
| - }
|
| - // find length of the common prefix
|
| - int length = -1;
|
| - for (int i = 0; i < minLength; i++) {
|
| - if (!allListsEqual(lists, i)) {
|
| - break;
|
| - }
|
| - length++;
|
| - }
|
| - // done
|
| - return lists.get(0).subList(0, length + 1);
|
| - }
|
| -
|
| -// /**
|
| -// * Returns the closest ancestor of <code>node</code> whose type is <code>nodeType</code>, or
|
| -// * <code>null</code> if none.
|
| -// * <p>
|
| -// * <b>Warning:</b> This method does not stop at any boundaries like parentheses, statements, body
|
| -// * declarations, etc. The resulting node may be in a totally different scope than the given node.
|
| -// * Consider using one of the {@link ASTResolving}<code>.find(..)</code> methods instead.
|
| -// * </p>
|
| -// *
|
| -// * @param node the node
|
| -// * @param nodeType the node type constant from {@link DartNode}
|
| -// * @return the closest ancestor of <code>node</code> whose type is <code>nodeType</code>, or
|
| -// * <code>null</code> if none
|
| -// */
|
| -// public static DartNode getParent(DartNode node, int nodeType) {
|
| -// do {
|
| -// node = node.getParent();
|
| -// } while (node != null && node.getNodeType() != nodeType);
|
| -// return node;
|
| -// }
|
| -//
|
| -// public static IProblem[] getProblems(DartNode node, int scope, int severity) {
|
| -// DartNode root = node.getRoot();
|
| -// if (!(root instanceof CompilationUnit)) {
|
| -// return EMPTY_PROBLEMS;
|
| -// }
|
| -// IProblem[] problems = ((CompilationUnit) root).getProblems();
|
| -// if (root == node) {
|
| -// return problems;
|
| -// }
|
| -// final int iterations = computeIterations(scope);
|
| -// List<IProblem> result = new ArrayList<IProblem>(5);
|
| -// for (int i = 0; i < problems.length; i++) {
|
| -// IProblem problem = problems[i];
|
| -// boolean consider = false;
|
| -// if ((severity & PROBLEMS) == PROBLEMS) {
|
| -// consider = true;
|
| -// } else if ((severity & WARNING) != 0) {
|
| -// consider = problem.isWarning();
|
| -// } else if ((severity & ERROR) != 0) {
|
| -// consider = problem.isError();
|
| -// }
|
| -// if (consider) {
|
| -// DartNode temp = node;
|
| -// int count = iterations;
|
| -// do {
|
| -// int nodeOffset = temp.getStartPosition();
|
| -// int problemOffset = problem.getSourceStart();
|
| -// if (nodeOffset <= problemOffset && problemOffset < nodeOffset + temp.getLength()) {
|
| -// result.add(problem);
|
| -// count = 0;
|
| -// } else {
|
| -// count--;
|
| -// }
|
| -// } while ((temp = temp.getParent()) != null && count > 0);
|
| -// }
|
| -// }
|
| -// return result.toArray(new IProblem[result.size()]);
|
| -// }
|
| -//
|
| -// public static String getQualifier(Name name) {
|
| -// if (name.isQualifiedName()) {
|
| -// return ((QualifiedName) name).getQualifier().getFullyQualifiedName();
|
| -// }
|
| -// return ""; //$NON-NLS-1$
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns the receiver's type binding of the given method invocation.
|
| -// *
|
| -// * @param invocation method invocation to resolve type of
|
| -// * @return the type binding of the receiver
|
| -// */
|
| -// public static ITypeBinding getReceiverTypeBinding(MethodInvocation invocation) {
|
| -// ITypeBinding result = null;
|
| -// Expression exp = invocation.getExpression();
|
| -// if (exp != null) {
|
| -// return exp.resolveTypeBinding();
|
| -// } else {
|
| -// AbstractTypeDeclaration type =
|
| -// (AbstractTypeDeclaration) getParent(invocation, AbstractTypeDeclaration.class);
|
| -// if (type != null) {
|
| -// return type.resolveBinding();
|
| -// }
|
| -// }
|
| -// return result;
|
| -// }
|
| -//
|
| -// public static String getSimpleNameIdentifier(Name name) {
|
| -// if (name.isQualifiedName()) {
|
| -// return ((QualifiedName) name).getName().getIdentifier();
|
| -// } else {
|
| -// return ((SimpleName) name).getIdentifier();
|
| -// }
|
| -// }
|
| -//
|
| -// public static Name getTopMostName(Name name) {
|
| -// Name result = name;
|
| -// while (result.getParent() instanceof Name) {
|
| -// result = (Name) result.getParent();
|
| -// }
|
| -// return result;
|
| -// }
|
| -//
|
| -// public static Type getTopMostType(Type type) {
|
| -// Type result = type;
|
| -// while (result.getParent() instanceof Type) {
|
| -// result = (Type) result.getParent();
|
| -// }
|
| -// return result;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns the type node for the given declaration.
|
| -// *
|
| -// * @param declaration the declaration
|
| -// * @return the type node
|
| -// */
|
| -// public static Type getType(VariableDeclaration declaration) {
|
| -// if (declaration instanceof SingleVariableDeclaration) {
|
| -// return ((SingleVariableDeclaration) declaration).getType();
|
| -// } else if (declaration instanceof VariableDeclarationFragment) {
|
| -// DartNode parent = ((VariableDeclarationFragment) declaration).getParent();
|
| -// if (parent instanceof VariableDeclarationExpression) {
|
| -// return ((VariableDeclarationExpression) parent).getType();
|
| -// } else if (parent instanceof VariableDeclarationStatement) {
|
| -// return ((VariableDeclarationStatement) parent).getType();
|
| -// } else if (parent instanceof FieldDeclaration) {
|
| -// return ((FieldDeclaration) parent).getType();
|
| -// }
|
| -// }
|
| -// Assert.isTrue(false, "Unknown VariableDeclaration"); //$NON-NLS-1$
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static ITypeBinding getTypeBinding(CompilationUnit root, IType type)
|
| -// throws JavaModelException {
|
| -// if (type.isAnonymous()) {
|
| -// final IJavaElement parent = type.getParent();
|
| -// if (parent instanceof IField && Flags.isEnum(((IMember) parent).getFlags())) {
|
| -// final EnumConstantDeclaration constant =
|
| -// (EnumConstantDeclaration) NodeFinder.perform(
|
| -// root,
|
| -// ((ISourceReference) parent).getSourceRange());
|
| -// if (constant != null) {
|
| -// final AnonymousClassDeclaration declaration = constant.getAnonymousClassDeclaration();
|
| -// if (declaration != null) {
|
| -// return declaration.resolveBinding();
|
| -// }
|
| -// }
|
| -// } else {
|
| -// final ClassInstanceCreation creation =
|
| -// (ClassInstanceCreation) getParent(
|
| -// NodeFinder.perform(root, type.getNameRange()),
|
| -// ClassInstanceCreation.class);
|
| -// if (creation != null) {
|
| -// return creation.resolveTypeBinding();
|
| -// }
|
| -// }
|
| -// } else {
|
| -// final AbstractTypeDeclaration declaration =
|
| -// (AbstractTypeDeclaration) getParent(
|
| -// NodeFinder.perform(root, type.getNameRange()),
|
| -// AbstractTypeDeclaration.class);
|
| -// if (declaration != null) {
|
| -// return declaration.resolveBinding();
|
| -// }
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static ITypeBinding getTypeBinding(Name node) {
|
| -// IBinding binding = node.resolveBinding();
|
| -// if (binding instanceof ITypeBinding) {
|
| -// return (ITypeBinding) binding;
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// public static String getTypeName(Type type) {
|
| -// final StringBuffer buffer = new StringBuffer();
|
| -// ASTVisitor visitor = new ASTVisitor() {
|
| -// @Override
|
| -// public void endVisit(ArrayType node) {
|
| -// buffer.append("[]"); //$NON-NLS-1$
|
| -// }
|
| -//
|
| -// @Override
|
| -// public boolean visit(PrimitiveType node) {
|
| -// buffer.append(node.getPrimitiveTypeCode().toString());
|
| -// return false;
|
| -// }
|
| -//
|
| -// @Override
|
| -// public boolean visit(QualifiedName node) {
|
| -// buffer.append(node.getName().getIdentifier());
|
| -// return false;
|
| -// }
|
| -//
|
| -// @Override
|
| -// public boolean visit(SimpleName node) {
|
| -// buffer.append(node.getIdentifier());
|
| -// return false;
|
| -// }
|
| -// };
|
| -// type.accept(visitor);
|
| -// return buffer.toString();
|
| -// }
|
| -//
|
| -// public static IVariableBinding getVariableBinding(Name node) {
|
| -// IBinding binding = node.resolveBinding();
|
| -// if (binding instanceof IVariableBinding) {
|
| -// return (IVariableBinding) binding;
|
| -// }
|
| -// return null;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns true if a node at a given location is a body of a control statement. Such body nodes
|
| -// * are interesting as when replacing them, it has to be evaluates if a Block is needed instead.
|
| -// * E.g. <code> if (x) do(); -> if (x) { do1(); do2() } </code>
|
| -// *
|
| -// * @param locationInParent Location of the body node
|
| -// * @return Returns true if the location is a body node location of a control statement.
|
| -// */
|
| -// public static boolean isControlStatementBody(StructuralPropertyDescriptor locationInParent) {
|
| -// return locationInParent == IfStatement.THEN_STATEMENT_PROPERTY
|
| -// || locationInParent == IfStatement.ELSE_STATEMENT_PROPERTY
|
| -// || locationInParent == ForStatement.BODY_PROPERTY
|
| -// || locationInParent == EnhancedForStatement.BODY_PROPERTY
|
| -// || locationInParent == WhileStatement.BODY_PROPERTY
|
| -// || locationInParent == DoStatement.BODY_PROPERTY;
|
| -// }
|
| -//
|
| -// public static boolean isDeclaration(Name name) {
|
| -// if (name.isQualifiedName()) {
|
| -// return ((QualifiedName) name).getName().isDeclaration();
|
| -// } else {
|
| -// return ((SimpleName) name).isDeclaration();
|
| -// }
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns true if this is an existing node, i.e. it was created as part of a parsing process of a
|
| -// * source code file. Returns false if this is a newly created node which has not yet been given a
|
| -// * source position.
|
| -// *
|
| -// * @param node the node to be tested.
|
| -// * @return true if this is an existing node, false if not.
|
| -// */
|
| -// public static boolean isExistingNode(DartNode node) {
|
| -// return node.getStartPosition() != -1;
|
| -// }
|
| -//
|
| -// public static boolean isLabel(SimpleName name) {
|
| -// int parentType = name.getParent().getNodeType();
|
| -// return parentType == DartNode.LABELED_STATEMENT
|
| -// || parentType == DartNode.BREAK_STATEMENT
|
| -// || parentType != DartNode.CONTINUE_STATEMENT;
|
| -// }
|
| -//
|
| -// public static boolean isLiteral(Expression expression) {
|
| -// int type = expression.getNodeType();
|
| -// return type == DartNode.BOOLEAN_LITERAL
|
| -// || type == DartNode.CHARACTER_LITERAL
|
| -// || type == DartNode.NULL_LITERAL
|
| -// || type == DartNode.NUMBER_LITERAL
|
| -// || type == DartNode.STRING_LITERAL
|
| -// || type == DartNode.TYPE_LITERAL;
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns <code>true</code> iff <code>parent</code> is a true ancestor of <code>node</code> (i.e.
|
| -// * returns <code>false</code> if <code>parent == node</code>).
|
| -// *
|
| -// * @param node node to test
|
| -// * @param parent assumed parent
|
| -// * @return <code>true</code> iff <code>parent</code> is a true ancestor of <code>node</code>
|
| -// */
|
| -// public static boolean isParent(DartNode node, DartNode parent) {
|
| -// Assert.isNotNull(parent);
|
| -// do {
|
| -// node = node.getParent();
|
| -// if (node == parent) {
|
| -// return true;
|
| -// }
|
| -// } while (node != null);
|
| -// return false;
|
| -// }
|
| -//
|
| -// public static boolean isSingleDeclaration(VariableDeclaration declaration) {
|
| -// Assert.isNotNull(declaration);
|
| -// if (declaration instanceof SingleVariableDeclaration) {
|
| -// return true;
|
| -// } else if (declaration instanceof VariableDeclarationFragment) {
|
| -// DartNode parent = declaration.getParent();
|
| -// if (parent instanceof VariableDeclarationExpression) {
|
| -// return ((VariableDeclarationExpression) parent).fragments().size() == 1;
|
| -// } else if (parent instanceof VariableDeclarationStatement) {
|
| -// return ((VariableDeclarationStatement) parent).fragments().size() == 1;
|
| -// }
|
| -// }
|
| -// return false;
|
| -// }
|
| -//
|
| -// public static boolean isStatic(BodyDeclaration declaration) {
|
| -// return Modifier.isStatic(declaration.getModifiers());
|
| -// }
|
| -//
|
| -// /**
|
| -// * Adds flags to the given node and all its descendants.
|
| -// *
|
| -// * @param root The root node
|
| -// * @param flags The flags to set
|
| -// */
|
| -// public static void setFlagsToAST(DartNode root, final int flags) {
|
| -// root.accept(new GenericVisitor(true) {
|
| -// @Override
|
| -// protected boolean visitNode(DartNode node) {
|
| -// node.setFlags(node.getFlags() | flags);
|
| -// return true;
|
| -// }
|
| -// });
|
| -// }
|
| -//
|
| -// private static int computeIterations(int flags) {
|
| -// switch (flags) {
|
| -// case NODE_ONLY:
|
| -// return 1;
|
| -// case INCLUDE_ALL_PARENTS:
|
| -// return Integer.MAX_VALUE;
|
| -// case INCLUDE_FIRST_PARENT:
|
| -// return 2;
|
| -// default:
|
| -// return 1;
|
| -// }
|
| -// }
|
| -//
|
| -// private static int getOrderPreference(BodyDeclaration member, MembersOrderPreferenceCache store) {
|
| -// int memberType = member.getNodeType();
|
| -// int modifiers = member.getModifiers();
|
| -//
|
| -// switch (memberType) {
|
| -// case DartNode.TYPE_DECLARATION:
|
| -// case DartNode.ENUM_DECLARATION:
|
| -// case DartNode.ANNOTATION_TYPE_DECLARATION:
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.TYPE_INDEX) * 2;
|
| -// case DartNode.FIELD_DECLARATION:
|
| -// if (Modifier.isStatic(modifiers)) {
|
| -// int index = store.getCategoryIndex(MembersOrderPreferenceCache.STATIC_FIELDS_INDEX) * 2;
|
| -// if (Modifier.isFinal(modifiers)) {
|
| -// return index; // first final static, then static
|
| -// }
|
| -// return index + 1;
|
| -// }
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.FIELDS_INDEX) * 2;
|
| -// case DartNode.INITIALIZER:
|
| -// if (Modifier.isStatic(modifiers)) {
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.STATIC_INIT_INDEX) * 2;
|
| -// }
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.INIT_INDEX) * 2;
|
| -// case DartNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.METHOD_INDEX) * 2;
|
| -// case DartNode.METHOD_DECLARATION:
|
| -// if (Modifier.isStatic(modifiers)) {
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.STATIC_METHODS_INDEX) * 2;
|
| -// }
|
| -// if (((MethodDeclaration) member).isConstructor()) {
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.CONSTRUCTORS_INDEX) * 2;
|
| -// }
|
| -// return store.getCategoryIndex(MembersOrderPreferenceCache.METHOD_INDEX) * 2;
|
| -// default:
|
| -// return 100;
|
| -// }
|
| -// }
|
| -//
|
| -// /**
|
| -// * Returns whether an expression at the given location needs explicit boxing.
|
| -// *
|
| -// * @param expression the expression
|
| -// * @return <code>true</code> iff an expression at the given location needs explicit boxing
|
| -// */
|
| -// private static boolean needsExplicitBoxing(Expression expression) {
|
| -// StructuralPropertyDescriptor locationInParent = expression.getLocationInParent();
|
| -// if (locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
|
| -// return needsExplicitBoxing((ParenthesizedExpression) expression.getParent());
|
| -// }
|
| -//
|
| -// if (locationInParent == ClassInstanceCreation.EXPRESSION_PROPERTY
|
| -// || locationInParent == FieldAccess.EXPRESSION_PROPERTY
|
| -// || locationInParent == MethodInvocation.EXPRESSION_PROPERTY) {
|
| -// return true;
|
| -// }
|
| -//
|
| -// return false;
|
| -// }
|
| -
|
| - private ASTNodes() {
|
| - // no instance;
|
| - }
|
| -
|
| - /**
|
| - * Looks to see if the property access requires a getter.
|
| - * <p>
|
| - * A property access requires a getter if it is on the right hand side of an assignment, or if it
|
| - * is on the left hand side of an assignment and uses one of the assignment operators other than
|
| - * plain '='.
|
| - * <p>
|
| - * Note, that we don't check if given {@link DartNode} is actually field name.
|
| - */
|
| - public static boolean inGetterContext(DartNode node) {
|
| - if (node.getParent() instanceof DartBinaryExpression) {
|
| - DartBinaryExpression expr = (DartBinaryExpression) node.getParent();
|
| - if (expr.getArg1() == node && expr.getOperator() == Token.ASSIGN) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - /**
|
| - * Looks to see if the property access requires a setter.
|
| - * <p>
|
| - * Basically, this boils down to any property access on the left hand side of an assignment.
|
| - * <p>
|
| - * Keep in mind that an assignment of the form node = <expr> is the only kind of write-only
|
| - * expression. Other types of assignments also read the value and require a getter access.
|
| - * <p>
|
| - * Note, that we don't check if given {@link DartNode} is actually field name.
|
| - */
|
| - public static boolean inSetterContext(DartNode node) {
|
| - if (node.getParent() instanceof DartUnaryExpression) {
|
| - DartUnaryExpression expr = (DartUnaryExpression) node.getParent();
|
| - return expr.getArg() == node && expr.getOperator().isCountOperator();
|
| - }
|
| - if (node.getParent() instanceof DartBinaryExpression) {
|
| - DartBinaryExpression expr = (DartBinaryExpression) node.getParent();
|
| - return expr.getArg1() == node && expr.getOperator().isAssignmentOperator();
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link DartIdentifier} corresponding to the name of constructor.
|
| - */
|
| - public static DartIdentifier getConstructorNameNode(DartNewExpression node) {
|
| - DartNode constructor = node.getConstructor();
|
| - return getConstructorNameNode(constructor);
|
| - }
|
| -
|
| - /**
|
| - * @return the {@link DartIdentifier} corresponding to the name of constructor.
|
| - */
|
| - private static DartIdentifier getConstructorNameNode(DartNode constructor) {
|
| - if (constructor instanceof DartPropertyAccess) {
|
| - return ((DartPropertyAccess) constructor).getName();
|
| - } else if (constructor instanceof DartTypeNode) {
|
| - return getConstructorNameNode(((DartTypeNode) constructor).getIdentifier());
|
| - } else {
|
| - return (DartIdentifier) constructor;
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given {@link DartNode} has {@link DartSuperExpression}.
|
| - */
|
| - public static boolean hasSuperInvocation(DartNode node) {
|
| - final AtomicBoolean result = new AtomicBoolean();
|
| - node.accept(new ASTVisitor<Void>() {
|
| - @Override
|
| - public Void visitSuperExpression(DartSuperExpression node) {
|
| - result.set(true);
|
| - return null;
|
| - }
|
| - });
|
| - return result.get();
|
| - }
|
| -
|
| -}
|
|
|
Chromium Code Reviews
Issue 20722006:
Removed compiler/ directory from repository (Closed)
Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge