dartfmt pkg/compiler

pkg/compiler/lib/src/elements/elements.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library elements;
 
 import '../common.dart';
-import '../common/resolution.dart' show
-    Resolution;
-import '../compiler.dart' show
-    Compiler;
+import '../common/resolution.dart' show Resolution;
+import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
-import '../core_types.dart' show
-    CoreClasses;
+import '../core_types.dart' show CoreClasses;
 import '../dart_types.dart';
-import '../resolution/scope.dart' show
-    Scope;
-import '../resolution/tree_elements.dart' show
-    TreeElements;
+import '../resolution/scope.dart' show Scope;
+import '../resolution/tree_elements.dart' show TreeElements;
 import '../ordered_typeset.dart' show OrderedTypeSet;
 import '../script.dart';
-import '../tokens/token.dart' show
-    Token,
-    isUserDefinableOperator,
-    isMinusOperator;
+import '../tokens/token.dart'
+    show Token, isUserDefinableOperator, isMinusOperator;
 import '../tree/tree.dart';
 import '../util/characters.dart' show $_;
 import '../util/util.dart';
 
 import 'visitor.dart' show ElementVisitor;
 
 part 'names.dart';
 
 const int STATE_NOT_STARTED = 0;
 const int STATE_STARTED = 1;
@@ skipping 386 matching lines @@
 
   static bool isError(Element e) {
     return e != null && e.isError;
   }
 
   static bool isMalformed(Element e) {
     return e != null && e.isMalformed;
   }
 
   /// Unwraps [element] reporting any warnings attached to it, if any.
-  static Element unwrap(Element element,
-                        DiagnosticReporter listener,
-                        Spannable spannable) {
+  static Element unwrap(
+      Element element, DiagnosticReporter listener, Spannable spannable) {
     if (element != null && element.isWarnOnUse) {
       WarnOnUseElement wrappedElement = element;
       element = wrappedElement.unwrap(listener, spannable);
     }
     return element;
   }
 
   static bool isClass(Element e) => e != null && e.kind == ElementKind.CLASS;
   static bool isTypedef(Element e) {
     return e != null && e.kind == ElementKind.TYPEDEF;
   }
 
   static bool isLocal(Element element) {
     return !Elements.isUnresolved(element) && element.isLocal;
   }
 
   static bool isInstanceField(Element element) {
-    return !Elements.isUnresolved(element)
-           && element.isInstanceMember
-           && (identical(element.kind, ElementKind.FIELD)
-               || identical(element.kind, ElementKind.GETTER)
-               || identical(element.kind, ElementKind.SETTER));
+    return !Elements.isUnresolved(element) &&
+        element.isInstanceMember &&
+        (identical(element.kind, ElementKind.FIELD) ||
+            identical(element.kind, ElementKind.GETTER) ||
+            identical(element.kind, ElementKind.SETTER));
   }
 
   static bool isStaticOrTopLevel(Element element) {
     // TODO(johnniwinther): Clean this up. This currently returns true for a
     // PartialConstructorElement, SynthesizedConstructorElementX, and
     // TypeVariableElementX though neither `element.isStatic` nor
     // `element.isTopLevel` is true.
     if (Elements.isUnresolved(element)) return false;
     if (element.isStatic || element.isTopLevel) return true;
-    return !element.isAmbiguous
-           && !element.isInstanceMember
-           && !element.isPrefix
-           && element.enclosingElement != null
-           && (element.enclosingElement.kind == ElementKind.CLASS ||
-               element.enclosingElement.kind == ElementKind.COMPILATION_UNIT ||
-               element.enclosingElement.kind == ElementKind.LIBRARY ||
-               element.enclosingElement.kind == ElementKind.PREFIX);
+    return !element.isAmbiguous &&
+        !element.isInstanceMember &&
+        !element.isPrefix &&
+        element.enclosingElement != null &&
+        (element.enclosingElement.kind == ElementKind.CLASS ||
+            element.enclosingElement.kind == ElementKind.COMPILATION_UNIT ||
+            element.enclosingElement.kind == ElementKind.LIBRARY ||
+            element.enclosingElement.kind == ElementKind.PREFIX);
   }
 
   static bool isInStaticContext(Element element) {
     if (isUnresolved(element)) return true;
     if (element.enclosingElement.isClosure) {
       var closureClass = element.enclosingElement;
       element = closureClass.methodElement;
     }
     Element outer = element.outermostEnclosingMemberOrTopLevel;
     if (isUnresolved(outer)) return true;
     if (outer.isTopLevel) return true;
     if (outer.isGenerativeConstructor) return false;
     if (outer.isInstanceMember) return false;
     return true;
   }
 
   static bool hasAccessToTypeVariables(Element element) {
     Element outer = element.outermostEnclosingMemberOrTopLevel;
     return (outer != null && outer.isFactoryConstructor) ||
         !isInStaticContext(element);
   }
 
   static bool isStaticOrTopLevelField(Element element) {
-    return isStaticOrTopLevel(element)
-           && (identical(element.kind, ElementKind.FIELD)
-               || identical(element.kind, ElementKind.GETTER)
-               || identical(element.kind, ElementKind.SETTER));
+    return isStaticOrTopLevel(element) &&
+        (identical(element.kind, ElementKind.FIELD) ||
+            identical(element.kind, ElementKind.GETTER) ||
+            identical(element.kind, ElementKind.SETTER));
   }
 
   static bool isStaticOrTopLevelFunction(Element element) {
     return isStaticOrTopLevel(element) && element.isFunction;
   }
 
   static bool isInstanceMethod(Element element) {
-    return !Elements.isUnresolved(element)
-           && element.isInstanceMember
-           && (identical(element.kind, ElementKind.FUNCTION));
+    return !Elements.isUnresolved(element) &&
+        element.isInstanceMember &&
+        (identical(element.kind, ElementKind.FUNCTION));
   }
 
   /// Also returns true for [ConstructorBodyElement]s and getters/setters.
   static bool isNonAbstractInstanceMember(Element element) {
     // The generative constructor body is not a function. We therefore treat
     // it specially.
     if (element.isGenerativeConstructorBody) return true;
     return !Elements.isUnresolved(element) &&
         !element.isAbstract &&
         element.isInstanceMember &&
         (element.isFunction || element.isAccessor);
   }
 
   static bool isInstanceSend(Send send, TreeElements elements) {
     Element element = elements[send];
     if (element == null) return !isClosureSend(send, element);
     return isInstanceMethod(element) ||
-           isInstanceField(element) ||
-           (send.isConditional && !element.isStatic);
+        isInstanceField(element) ||
+        (send.isConditional && !element.isStatic);
   }
 
   static bool isClosureSend(Send send, Element element) {
     if (send.isPropertyAccess) return false;
     if (send.receiver != null) return false;
     Node selector = send.selector;
     // this().
     if (selector.isThis()) return true;
     // (o)() or foo()().
     if (element == null && selector.asIdentifier() == null) return true;
@@ skipping 13 matching lines @@
   // TODO(johnniwinther): Remove this method.
   static String reconstructConstructorName(Element element) {
     String className = element.enclosingClass.name;
     if (element.name == '') {
       return className;
     } else {
       return '$className\$${element.name}';
     }
   }
 
-  static String constructorNameForDiagnostics(String className,
-                                              String constructorName) {
+  static String constructorNameForDiagnostics(
+      String className, String constructorName) {
     String classNameString = className;
     String constructorNameString = constructorName;
     return (constructorName == '')
         ? classNameString
         : "$classNameString.$constructorNameString";
   }
 
   /// Returns `true` if [name] is the name of an operator method.
   static bool isOperatorName(String name) {
     return name == 'unary-' || isUserDefinableOperator(name);
@@ skipping 61 matching lines @@
       return isUnary ? 'unary-' : op;
     } else if (isUserDefinableOperator(op) || op == '??') {
       return op;
     } else {
       return null;
     }
   }
 
   static String constructOperatorName(String op, bool isUnary) {
     String operatorName = constructOperatorNameOrNull(op, isUnary);
-    if (operatorName == null) throw 'Unhandled operator: $op';
-    else return operatorName;
+    if (operatorName == null)
+      throw 'Unhandled operator: $op';
+    else
+      return operatorName;
   }
 
   static String mapToUserOperatorOrNull(String op) {
     if (identical(op, '!=')) return '==';
     if (identical(op, '*=')) return '*';
     if (identical(op, '/=')) return '/';
     if (identical(op, '%=')) return '%';
     if (identical(op, '~/=')) return '~/';
     if (identical(op, '+=')) return '+';
     if (identical(op, '-=')) return '-';
@@ skipping 40 matching lines @@
     if (r != 0) return r;
     // Same file, position and name.  If this happens, we should find out why
     // and make the order total and independent of hashCode.
     return a.hashCode.compareTo(b.hashCode);
   }
 
   static List<Element> sortedByPosition(Iterable<Element> elements) {
     return elements.toList()..sort(compareByPosition);
   }
 
-  static bool isFixedListConstructorCall(Element element,
-                                         Send node,
-                                         Compiler compiler) {
-    return element == compiler.unnamedListConstructor
-        && node.isCall
-        && !node.arguments.isEmpty
-        && node.arguments.tail.isEmpty;
+  static bool isFixedListConstructorCall(
+      Element element, Send node, Compiler compiler) {
+    return element == compiler.unnamedListConstructor &&
+        node.isCall &&
+        !node.arguments.isEmpty &&
+        node.arguments.tail.isEmpty;
   }
 
-  static bool isGrowableListConstructorCall(Element element,
-                                            Send node,
-                                            Compiler compiler) {
-    return element == compiler.unnamedListConstructor
-        && node.isCall
-        && node.arguments.isEmpty;
+  static bool isGrowableListConstructorCall(
+      Element element, Send node, Compiler compiler) {
+    return element == compiler.unnamedListConstructor &&
+        node.isCall &&
+        node.arguments.isEmpty;
   }
 
-  static bool isFilledListConstructorCall(Element element,
-                                          Send node,
-                                          Compiler compiler) {
-    return element == compiler.filledListConstructor
-        && node.isCall
-        && !node.arguments.isEmpty
-        && !node.arguments.tail.isEmpty
-        && node.arguments.tail.tail.isEmpty;
+  static bool isFilledListConstructorCall(
+      Element element, Send node, Compiler compiler) {
+    return element == compiler.filledListConstructor &&
+        node.isCall &&
+        !node.arguments.isEmpty &&
+        !node.arguments.tail.isEmpty &&
+        node.arguments.tail.tail.isEmpty;
   }
 
-  static bool isConstructorOfTypedArraySubclass(Element element,
-                                                Compiler compiler) {
+  static bool isConstructorOfTypedArraySubclass(
+      Element element, Compiler compiler) {
     if (compiler.typedDataLibrary == null) return false;
     if (!element.isConstructor) return false;
     ConstructorElement constructor = element.implementation;
     constructor = constructor.effectiveTarget;
     ClassElement cls = constructor.enclosingClass;
-    return cls.library == compiler.typedDataLibrary
-        && compiler.backend.isNative(cls)
-        && compiler.world.isSubtypeOf(cls, compiler.typedDataClass)
-        && compiler.world.isSubtypeOf(cls, compiler.coreClasses.listClass)
-        && constructor.name == '';
+    return cls.library == compiler.typedDataLibrary &&
+        compiler.backend.isNative(cls) &&
+        compiler.world.isSubtypeOf(cls, compiler.typedDataClass) &&
+        compiler.world.isSubtypeOf(cls, compiler.coreClasses.listClass) &&
+        constructor.name == '';
   }
 
-  static bool switchStatementHasContinue(SwitchStatement node,
-                                         TreeElements elements) {
+  static bool switchStatementHasContinue(
+      SwitchStatement node, TreeElements elements) {
     for (SwitchCase switchCase in node.cases) {
       for (Node labelOrCase in switchCase.labelsAndCases) {
         Node label = labelOrCase.asLabel();
         if (label != null) {
           LabelDefinition labelElement = elements.getLabelDefinition(label);
           if (labelElement != null && labelElement.isContinueTarget) {
             return true;
           }
         }
       }
@@ skipping 177 matching lines @@
   /// Is true if this prefix belongs to a deferred import.
   bool get isDeferred;
 
   /// Import that declared this deferred prefix.
   ImportElement get deferredImport;
 }
 
 /// A type alias definition.
 abstract class TypedefElement extends Element
     implements AstElement, TypeDeclarationElement, FunctionTypedElement {
-
   /// The type defined by this typedef with the type variables as its type
   /// arguments.
   ///
   /// For instance `F<T>` for `typedef void F<T>(T t)`.
   TypedefType get thisType;
 
   /// The type defined by this typedef with `dynamic` as its type arguments.
   ///
   /// For instance `F<dynamic>` for `typedef void F<T>(T t)`.
   TypedefType get rawType;
@@ skipping 30 matching lines @@
 abstract class MemberElement extends Element implements ExecutableElement {
   /// The local functions defined within this member.
   List<FunctionElement> get nestedClosures;
 
   /// The name of this member, taking privacy into account.
   Name get memberName;
 }
 
 /// A function, variable or parameter defined in an executable context.
 abstract class LocalElement extends Element
-    implements AstElement, TypedElement, Local {
-}
+    implements AstElement, TypedElement, Local {}
 
 /// A top level, static or instance field, a formal parameter or local variable.
 abstract class VariableElement extends ExecutableElement {
   @override
   VariableDefinitions get node;
 
   Expression get initializer;
 
   /// The constant expression defining the value of the variable if `const`,
   /// `null` otherwise.
@@ skipping 14 matching lines @@
 abstract class Local extends Entity {
   /// The context in which this local is defined.
   ExecutableElement get executableContext;
 }
 
 /// A variable or parameter that is local to an executable context.
 ///
 /// The executable context is the [ExecutableElement] in which this variable
 /// is defined.
 abstract class LocalVariableElement extends VariableElement
-    implements LocalElement {
-}
+    implements LocalElement {}
 
 /// A top-level, static or instance field.
-abstract class FieldElement extends VariableElement implements MemberElement {
-}
+abstract class FieldElement extends VariableElement implements MemberElement {}
 
 /// A parameter-like element of a function signature.
 ///
 /// If the function signature comes from a typedef or an inline function-typed
 /// parameter (e.g. the parameter 'f' in `method(void f())`), then its
 /// parameters are not real parameters in that they can take no argument and
 /// hold no value. Such parameter-like elements are modeled by [FormalElement].
 ///
 /// If the function signature comes from a function or constructor, its
 /// parameters are real parameters and are modeled by [ParameterElement].
@@ skipping 27 matching lines @@
   /// `true` if this parameter is named.
   bool get isNamed;
 
   /// `true` if this parameter is optional.
   bool get isOptional;
 }
 
 /// A formal parameter on a function or constructor that introduces a local
 /// variable in the scope of the function or constructor.
 abstract class LocalParameterElement extends ParameterElement
-    implements LocalVariableElement {
-}
+    implements LocalVariableElement {}
 
 /// A formal parameter in a constructor that directly initializes a field.
 ///
 /// For example: `A(this.field)`.
 abstract class InitializingFormalElement extends ParameterElement {
   /// The field initialized by this initializing formal.
   FieldElement get fieldElement;
 
   /// The function on which this parameter is declared.
   ConstructorElement get functionDeclaration;
@@ skipping 30 matching lines @@
   void forEachOptionalParameter(void function(FormalElement parameter));
 
   void orderedForEachParameter(void function(FormalElement parameter));
 
   bool isCompatibleWith(FunctionSignature constructorSignature);
 }
 
 /// A top level, static or instance method, constructor, local function, or
 /// closure (anonymous local function).
 abstract class FunctionElement extends Element
-    implements AstElement,
-               TypedElement,
-               FunctionTypedElement,
-               ExecutableElement {
+    implements
+        AstElement,
+        TypedElement,
+        FunctionTypedElement,
+        ExecutableElement {
   FunctionExpression get node;
 
   FunctionElement get patch;
   FunctionElement get origin;
 
   bool get hasFunctionSignature;
 
   /// The parameters of this functions.
   List<ParameterElement> get parameters;
 
@@ skipping 50 matching lines @@
   final bool isYielding;
 
   const AsyncMarker._({this.isAsync: false, this.isYielding: false});
 
   String toString() {
     return '${isAsync ? 'async' : 'sync'}${isYielding ? '*' : ''}';
   }
 }
 
 /// A top level, static or instance function.
-abstract class MethodElement extends FunctionElement
-    implements MemberElement {
-}
+abstract class MethodElement extends FunctionElement implements MemberElement {}
 
 /// A local function or closure (anonymous local function).
 abstract class LocalFunctionElement extends FunctionElement
-    implements LocalElement {
-}
+    implements LocalElement {}
 
 /// A constructor.
 abstract class ConstructorElement extends FunctionElement
     implements MemberElement {
   /// The effective target of this constructor, that is the non-redirecting
   /// constructor that is called on invocation of this constructor.
   ///
   /// Consider for instance this hierachy:
   ///
   ///     class C { factory C.c() = D.d; }
@@ skipping 226 matching lines @@
   void reverseBackendMembers();
 
   Element lookupMember(String memberName);
   Element lookupByName(Name memberName);
   Element lookupSuperByName(Name memberName);
 
   Element lookupLocalMember(String memberName);
   Element lookupBackendMember(String memberName);
   Element lookupSuperMember(String memberName);
 
-  Element lookupSuperMemberInLibrary(String memberName,
-                                     LibraryElement library);
+  Element lookupSuperMemberInLibrary(String memberName, LibraryElement library);
 
   ConstructorElement lookupDefaultConstructor();
   ConstructorElement lookupConstructor(String name);
 
   void forEachMember(void f(ClassElement enclosingClass, Element member),
-                     {bool includeBackendMembers: false,
-                      bool includeSuperAndInjectedMembers: false});
+      {bool includeBackendMembers: false,
+      bool includeSuperAndInjectedMembers: false});
 
-  void forEachInstanceField(void f(ClassElement enclosingClass,
-                                   FieldElement field),
-                            {bool includeSuperAndInjectedMembers: false});
+  void forEachInstanceField(
+      void f(ClassElement enclosingClass, FieldElement field),
+      {bool includeSuperAndInjectedMembers: false});
 
   /// Similar to [forEachInstanceField] but visits static fields.
   void forEachStaticField(void f(ClassElement enclosingClass, Element field));
 
   void forEachBackendMember(void f(Element member));
 
   /// Looks up the member [name] in this class.
   Member lookupClassMember(Name name);
 
   /// Calls [f] with each member of this class.
@@ skipping 224 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }
-