dartfmt pkg/compiler

pkg/compiler/lib/src/resolution/access_semantics.dart

 // Copyright (c) 2015, 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.
 
 /**
  * Code for classifying the semantics of identifiers appearing in a Dart file.
  */
 library dart2js.access_semantics;
 
 import '../constants/expressions.dart';
@@ skipping 131 matching lines @@
   UNRESOLVED_SUPER,
 
   /// The destination is invalid as an access. For instance a prefix used
   /// as an expression.
   INVALID,
 }
 
 enum CompoundAccessKind {
   /// Read from a static getter and write to a static setter.
   STATIC_GETTER_SETTER,
+
   /// Read from a static method (closurize) and write to a static setter.
   STATIC_METHOD_SETTER,
 
   /// Read from an unresolved static getter and write to a static setter.
   UNRESOLVED_STATIC_GETTER,
+
   /// Read from a static getter and write to an unresolved static setter.
   UNRESOLVED_STATIC_SETTER,
 
   /// Read from a top level getter and write to a top level setter.
   TOPLEVEL_GETTER_SETTER,
+
   /// Read from a top level method (closurize) and write to top level setter.
   TOPLEVEL_METHOD_SETTER,
 
   /// Read from an unresolved top level getter and write to a top level setter.
   UNRESOLVED_TOPLEVEL_GETTER,
+
   /// Read from a top level getter and write to an unresolved top level setter.
   UNRESOLVED_TOPLEVEL_SETTER,
 
   /// Read from one superclass field and write to another.
   SUPER_FIELD_FIELD,
+
   /// Read from a superclass field and write to a superclass setter.
   SUPER_FIELD_SETTER,
+
   /// Read from a superclass getter and write to a superclass setter.
   SUPER_GETTER_SETTER,
+
   /// Read from a superclass method (closurize) and write to a superclass
   /// setter.
   SUPER_METHOD_SETTER,
+
   /// Read from a superclass getter and write to a superclass field.
   SUPER_GETTER_FIELD,
 
   /// Read from a superclass where the getter is unresolved.
   // TODO(johnniwinther): Use [AccessKind.SUPER_GETTER] when the erroneous
   // element is no longer needed.
   UNRESOLVED_SUPER_GETTER,
+
   /// Read from a superclass getter and write to an unresolved setter.
   // TODO(johnniwinther): Use [AccessKind.SUPER_SETTER] when the erroneous
   // element is no longer needed.
   UNRESOLVED_SUPER_SETTER,
 }
 
 /**
  * Data structure used to classify the semantics of a property access or method
  * or function invocation.
  */
@@ skipping 40 matching lines @@
       }
     } else if (name != null) {
       sb.write('name=');
       sb.write(name);
     }
     sb.write(']');
     return sb.toString();
   }
 }
 
-
 class DynamicAccess extends AccessSemantics {
   final Name name;
 
   const DynamicAccess.expression()
       : name = null,
         super._(AccessKind.EXPRESSION);
 
   const DynamicAccess.thisAccess()
       : name = null,
         super._(AccessKind.THIS);
 
   const DynamicAccess.thisProperty(this.name)
       : super._(AccessKind.THIS_PROPERTY);
 
   const DynamicAccess.dynamicProperty(this.name)
       : super._(AccessKind.DYNAMIC_PROPERTY);
 
   const DynamicAccess.ifNotNullProperty(this.name)
       : super._(AccessKind.CONDITIONAL_DYNAMIC_PROPERTY);
 }
 
 class ConstantAccess extends AccessSemantics {
   final ConstantExpression constant;
 
-  ConstantAccess(AccessKind kind, this.constant)
-      : super._(kind);
+  ConstantAccess(AccessKind kind, this.constant) : super._(kind);
 
   ConstantAccess.classTypeLiteral(this.constant)
       : super._(AccessKind.CLASS_TYPE_LITERAL);
 
   ConstantAccess.typedefTypeLiteral(this.constant)
       : super._(AccessKind.TYPEDEF_TYPE_LITERAL);
 
   ConstantAccess.dynamicTypeLiteral(this.constant)
       : super._(AccessKind.DYNAMIC_TYPE_LITERAL);
 }
 
 class StaticAccess extends AccessSemantics {
   final Element element;
 
-  StaticAccess._(AccessKind kind, this.element)
-      : super._(kind);
+  StaticAccess._(AccessKind kind, this.element) : super._(kind);
 
   StaticAccess.superSetter(MethodElement this.element)
       : super._(AccessKind.SUPER_SETTER);
 
   StaticAccess.superField(FieldElement this.element)
       : super._(AccessKind.SUPER_FIELD);
 
   StaticAccess.superFinalField(FieldElement this.element)
       : super._(AccessKind.SUPER_FINAL_FIELD);
 
@@ skipping 44 matching lines @@
 
   StaticAccess.topLevelMethod(MethodElement this.element)
       : super._(AccessKind.TOPLEVEL_METHOD);
 
   StaticAccess.topLevelGetter(MethodElement this.element)
       : super._(AccessKind.TOPLEVEL_GETTER);
 
   StaticAccess.topLevelSetter(MethodElement this.element)
       : super._(AccessKind.TOPLEVEL_SETTER);
 
-  StaticAccess.unresolved(this.element)
-      : super._(AccessKind.UNRESOLVED);
+  StaticAccess.unresolved(this.element) : super._(AccessKind.UNRESOLVED);
 
   StaticAccess.unresolvedSuper(this.element)
       : super._(AccessKind.UNRESOLVED_SUPER);
 
-  StaticAccess.invalid(this.element)
-      : super._(AccessKind.INVALID);
+  StaticAccess.invalid(this.element) : super._(AccessKind.INVALID);
 }
 
 class CompoundAccessSemantics extends AccessSemantics {
   final CompoundAccessKind compoundAccessKind;
   final Element getter;
   final Element setter;
 
-  CompoundAccessSemantics(this.compoundAccessKind,
-                          this.getter,
-                          this.setter)
+  CompoundAccessSemantics(this.compoundAccessKind, this.getter, this.setter)
       : super._(AccessKind.COMPOUND);
 
   Element get element => setter;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('CompoundAccessSemantics[');
     sb.write('kind=$compoundAccessKind');
     if (getter != null) {
       sb.write(',getter=');
@@ skipping 93 matching lines @@
   /// The invoked constructor.
   final Element element;
 
   /// The type on which the constructor is invoked.
   final DartType type;
 
   ConstructorAccessSemantics(this.kind, this.element, this.type);
 
   String toString() => 'ConstructorAccessSemantics($kind, $element, $type)';
 }