dartfmt pkg/compiler

pkg/compiler/lib/src/serialization/modelz.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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
 
 import '../common.dart';
-import '../common/resolution.dart' show
-    Resolution;
+import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
-import '../elements/modelx.dart' show
-    FunctionSignatureX;
+import '../elements/modelx.dart' show FunctionSignatureX;
 import '../elements/common.dart';
 import '../elements/visitor.dart';
 import '../io/source_file.dart';
 import '../ordered_typeset.dart';
 import '../resolution/class_members.dart' as class_members;
-import '../resolution/tree_elements.dart' show
-    TreeElements;
-import '../resolution/scope.dart' show
-    Scope;
+import '../resolution/tree_elements.dart' show TreeElements;
+import '../resolution/scope.dart' show Scope;
 import '../script.dart';
 import '../serialization/constant_serialization.dart';
-import '../tokens/token.dart' show
-    Token;
+import '../tokens/token.dart' show Token;
 import '../tree/tree.dart';
-import '../util/util.dart' show
-    Link,
-    LinkBuilder;
+import '../util/util.dart' show Link, LinkBuilder;
 
 import 'keys.dart';
 import 'serialization.dart';
 
 /// Compute a [Link] from an [Iterable].
 Link toLink(Iterable iterable) {
   LinkBuilder builder = new LinkBuilder();
   for (var element in iterable) {
     builder.addLast(element);
   }
@@ skipping 203 matching lines @@
     }
   }
 
   Element lookup(String name) => _lookupMap[name];
 
   void forEach(f(Element element)) => _lookupMap.values.forEach(f);
 
   Iterable<Element> get values => _lookupMap.values;
 }
 
-
 abstract class AnalyzableElementMixin implements AnalyzableElement, ElementZ {
   @override
   bool get hasTreeElements => _unsupported('hasTreeElements');
 
   @override
   TreeElements get treeElements => _unsupported('treeElements');
 }
 
-
 abstract class AstElementMixin implements AstElement, ElementZ {
   @override
   bool get hasNode => _unsupported('hasNode');
 
   @override
   bool get hasResolvedAst => _unsupported('hasResolvedAst');
 
   @override
   get node => _unsupported('node');
 
   @override
   ResolvedAst get resolvedAst => _unsupported('resolvedAst');
 }
 
 abstract class ContainerMixin
     implements DeserializedElementZ, ScopeContainerElement {
   MappedContainer _membersMap = new MappedContainer();
 
   @override
   Element localLookup(String name) {
     return _membersMap.lookup(
         name, _decoder.getMap(Key.MEMBERS, isOptional: true));
   }
 
   @override
   void forEachLocalMember(f(Element element)) {
-    MapDecoder members =
-        _decoder.getMap(Key.MEMBERS, isOptional: true);
+    MapDecoder members = _decoder.getMap(Key.MEMBERS, isOptional: true);
     if (members == null) return;
     members.forEachKey((String key) {
       Element member = members.getElement(key);
       if (member != null) {
         f(member);
       }
     });
   }
 }
 
@@ skipping 35 matching lines @@
   Element get enclosingElement => _canonicalElement.enclosingElement;
 
   @override
   SourceSpan get sourcePosition => _canonicalElement.sourcePosition;
 
   @override
   ClassElement get enclosingClass => _canonicalElement.enclosingClass;
 }
 
 class LibraryElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         ContainerMixin,
-         LibraryElementCommon
+    with AnalyzableElementMixin, ContainerMixin, LibraryElementCommon
     implements LibraryElement {
   Uri _canonicalUri;
   CompilationUnitElement _entryCompilationUnit;
   Link<CompilationUnitElement> _compilationUnits;
   List<ImportElement> _imports;
   List<ExportElement> _exports;
   ListedContainer _exportsMap;
   ListedContainer _importsMap;
 
-  LibraryElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  LibraryElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.LIBRARY;
 
   @override
   Element get enclosingElement => null;
 
   @override
   String get name => entryCompilationUnit.name;
 
@@ skipping 20 matching lines @@
   CompilationUnitElement get entryCompilationUnit {
     if (_entryCompilationUnit == null) {
       _entryCompilationUnit = _decoder.getElement(Key.COMPILATION_UNIT);
     }
     return _entryCompilationUnit;
   }
 
   @override
   Link<CompilationUnitElement> get compilationUnits {
     if (_compilationUnits == null) {
-      _compilationUnits =
-          toLink(_decoder.getElements(Key.COMPILATION_UNITS));
+      _compilationUnits = toLink(_decoder.getElements(Key.COMPILATION_UNITS));
     }
     return _compilationUnits;
   }
 
   @override
   bool get hasLibraryName {
     return libraryName != '';
   }
 
   @override
@@ skipping 94 matching lines @@
   // TODO(johnniwinther): Support the distinction between [readableUri] and
   // [resourceUri]; needed for platform libraries.
   @override
   Uri get readableUri => resourceUri;
 
   @override
   String get text => throw new UnsupportedError('ScriptZ.text');
 }
 
 class CompilationUnitElementZ extends DeserializedElementZ
-    with LibraryMemberMixin,
-         CompilationUnitElementCommon
+    with LibraryMemberMixin, CompilationUnitElementCommon
     implements CompilationUnitElement {
   List<Element> _members;
   Script _script;
 
-  CompilationUnitElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  CompilationUnitElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
 
   @override
   CompilationUnitElement get compilationUnit => this;
 
   @override
   Element get enclosingElement => library;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitCompilationUnitElement(this, arg);
   }
 
   @override
   void forEachLocalMember(f(Element element)) {
     if (_members == null) {
-      _members =
-          _decoder.getElements(Key.ELEMENTS, isOptional: true);
+      _members = _decoder.getElements(Key.ELEMENTS, isOptional: true);
     }
     _members.forEach(f);
   }
 
   @override
   Script get script {
     if (_script == null) {
       Uri resolvedUri = _decoder.getUri(Key.URI);
       _script = new ScriptZ(resolvedUri);
     }
     return _script;
   }
 
   @override
   String get name => script.name;
 }
 
-
 abstract class LibraryMemberMixin implements DeserializedElementZ {
   LibraryElement _library;
   CompilationUnitElement _compilationUnit;
 
   @override
   LibraryElement get library {
     if (_library == null) {
       _library = _decoder.getElement(Key.LIBRARY);
     }
     return _library;
@@ skipping 56 matching lines @@
 }
 
 abstract class StaticMemberMixin implements DeserializedElementZ {
   @override
   bool get isTopLevel => false;
 
   @override
   bool get isStatic => true;
 }
 
-abstract class TypedElementMixin
-    implements DeserializedElementZ, TypedElement {
+abstract class TypedElementMixin implements DeserializedElementZ, TypedElement {
   DartType _type;
 
   @override
   DartType get type {
     if (_type == null) {
       _type = _decoder.getType(Key.TYPE);
     }
     return _type;
   }
 
@@ skipping 34 matching lines @@
             optionalParameterTypes.add(parameter.type);
           }
         } else {
           requiredParameterCount++;
           optionalParameters.add(parameter);
           parameterTypes.add(parameter.type);
         }
       }
       if (optionalParametersAreNamed) {
         orderedOptionalParameters.sort((Element a, Element b) {
-            return a.name.compareTo(b.name);
+          return a.name.compareTo(b.name);
         });
       }
 
       FunctionType type = new FunctionType(
           this,
           _decoder.getType(Key.RETURN_TYPE),
           parameterTypes,
           optionalParameterTypes,
           namedParameters,
           namedParameterTypes);
@@ skipping 20 matching lines @@
 abstract class FunctionTypedElementMixin
     implements FunctionElement, DeserializedElementZ {
   @override
   AsyncMarker get asyncMarker => _unsupported('asyncMarker');
 
   @override
   FunctionElement asFunctionElement() => this;
 
   @override
   bool get isExternal {
-    return _decoder.getBool(
-        Key.IS_EXTERNAL, isOptional: true, defaultValue: false);
+    return _decoder.getBool(Key.IS_EXTERNAL,
+        isOptional: true, defaultValue: false);
   }
 }
 
 abstract class ClassElementMixin implements ElementZ, ClassElement {
   InterfaceType _createType(List<DartType> typeArguments) {
     return new InterfaceType(this, typeArguments);
   }
 
   @override
   ElementKind get kind => ElementKind.CLASS;
@@ skipping 41 matching lines @@
   @override
   void reverseBackendMembers() => _unsupported('reverseBackendMembers');
 
   @override
   ClassElement get superclass => supertype != null ? supertype.element : null;
 
   @override
   void ensureResolved(Resolution resolution) {
     resolution.registerClass(this);
   }
-
 }
 
 class ClassElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         ClassElementCommon,
-         class_members.ClassMemberMixin,
-         ContainerMixin,
-         LibraryMemberMixin,
-         TypeDeclarationMixin<InterfaceType>,
-         ClassElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixin,
+        ClassElementCommon,
+        class_members.ClassMemberMixin,
+        ContainerMixin,
+        LibraryMemberMixin,
+        TypeDeclarationMixin<InterfaceType>,
+        ClassElementMixin
     implements ClassElement {
   bool _isObject;
   DartType _supertype;
   OrderedTypeSet _allSupertypesAndSelf;
   Link<DartType> _interfaces;
   FunctionType _callType;
 
-  ClassElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  ClassElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   List<DartType> _getTypeVariables() {
     return _decoder.getTypes(Key.TYPE_VARIABLES, isOptional: true);
   }
 
   void _ensureSuperHierarchy() {
     if (_interfaces == null) {
       InterfaceType supertype =
           _decoder.getType(Key.SUPERTYPE, isOptional: true);
       if (supertype == null) {
         _isObject = true;
         _allSupertypesAndSelf = new OrderedTypeSet.singleton(thisType);
         _interfaces = const Link<DartType>();
       } else {
         _isObject = false;
-        _interfaces = toLink(
-            _decoder.getTypes(Key.INTERFACES, isOptional: true));
+        _interfaces =
+            toLink(_decoder.getTypes(Key.INTERFACES, isOptional: true));
         List<InterfaceType> mixins =
             _decoder.getTypes(Key.MIXINS, isOptional: true);
         for (InterfaceType mixin in mixins) {
           MixinApplicationElement mixinElement =
               new UnnamedMixinApplicationElementZ(this, supertype, mixin);
-          supertype = mixinElement.thisType.subst(
-              typeVariables, mixinElement.typeVariables);
+          supertype = mixinElement.thisType
+              .subst(typeVariables, mixinElement.typeVariables);
         }
         _supertype = supertype;
-        _allSupertypesAndSelf =
-            new OrderedTypeSetBuilder(this)
-              .createOrderedTypeSet(_supertype, _interfaces);
+        _allSupertypesAndSelf = new OrderedTypeSetBuilder(this)
+            .createOrderedTypeSet(_supertype, _interfaces);
         _callType = _decoder.getType(Key.CALL_TYPE, isOptional: true);
       }
     }
   }
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitClassElement(this, arg);
   }
 
@@ skipping 57 matching lines @@
           builder.addLast(
               new ForwardingConstructorElementZ(this, definingConstructor));
         }
       }
       _constructors = builder.toLink();
     }
     return _constructors;
   }
 }
 
-
 class NamedMixinApplicationElementZ extends ClassElementZ
-    with MixinApplicationElementCommon,
-         MixinApplicationElementMixin {
+    with MixinApplicationElementCommon, MixinApplicationElementMixin {
   InterfaceType _mixinType;
 
-  NamedMixinApplicationElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  NamedMixinApplicationElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
-  InterfaceType get mixinType =>_mixinType ??= _decoder.getType(Key.MIXIN);
+  InterfaceType get mixinType => _mixinType ??= _decoder.getType(Key.MIXIN);
 }
 
-
 class UnnamedMixinApplicationElementZ extends ElementZ
-    with ClassElementCommon,
-         ClassElementMixin,
-         class_members.ClassMemberMixin,
-         TypeDeclarationMixin<InterfaceType>,
-         AnalyzableElementMixin,
-         AstElementMixin,
-         MixinApplicationElementCommon,
-         MixinApplicationElementMixin {
+    with
+        ClassElementCommon,
+        ClassElementMixin,
+        class_members.ClassMemberMixin,
+        TypeDeclarationMixin<InterfaceType>,
+        AnalyzableElementMixin,
+        AstElementMixin,
+        MixinApplicationElementCommon,
+        MixinApplicationElementMixin {
   final String name;
   final ClassElement _subclass;
   final InterfaceType supertype;
   final Link<DartType> interfaces;
   OrderedTypeSet _allSupertypesAndSelf;
 
   UnnamedMixinApplicationElementZ(
-      ClassElement subclass,
-      InterfaceType supertype, InterfaceType mixin)
+      ClassElement subclass, InterfaceType supertype, InterfaceType mixin)
       : this._subclass = subclass,
         this.supertype = supertype,
         this.interfaces = const Link<DartType>().prepend(mixin),
         this.name = "${supertype.name}+${mixin.name}";
 
   @override
   CompilationUnitElement get compilationUnit => _subclass.compilationUnit;
 
   @override
   bool get isUnnamedMixinApplication => true;
@@ skipping 22 matching lines @@
   }
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMixinApplicationElement(this, arg);
   }
 
   @override
   OrderedTypeSet get allSupertypesAndSelf {
     if (_allSupertypesAndSelf == null) {
-      _allSupertypesAndSelf =
-          new OrderedTypeSetBuilder(this)
-            .createOrderedTypeSet(supertype, interfaces);
+      _allSupertypesAndSelf = new OrderedTypeSetBuilder(this)
+          .createOrderedTypeSet(supertype, interfaces);
     }
     return _allSupertypesAndSelf;
   }
 
   @override
   Element get enclosingElement => _subclass.enclosingElement;
 
   @override
   bool get isObject => false;
 
   @override
   bool get isProxy => false;
 
   @override
   LibraryElement get library => enclosingElement.library;
 
   @override
   InterfaceType get mixinType => interfaces.head;
 
   @override
   SourceSpan get sourcePosition => _subclass.sourcePosition;
 }
 
-
 class EnumClassElementZ extends ClassElementZ implements EnumClassElement {
   List<FieldElement> _enumValues;
 
-  EnumClassElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  EnumClassElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   bool get isEnumClass => true;
 
   @override
   List<FieldElement> get enumValues {
     if (_enumValues == null) {
       _enumValues = _decoder.getElements(Key.FIELDS);
     }
     return _enumValues;
   }
 }
 
 abstract class ConstructorElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         ClassMemberMixin,
-         FunctionTypedElementMixin,
-         ParametersMixin,
-         TypedElementMixin,
-         MemberElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixin,
+        ClassMemberMixin,
+        FunctionTypedElementMixin,
+        ParametersMixin,
+        TypedElementMixin,
+        MemberElementMixin
     implements ConstructorElement {
   ConstantConstructor _constantConstructor;
 
-  ConstructorElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  ConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 
   @override
   bool get isConst => _decoder.getBool(Key.IS_CONST);
 
   @override
   bool get isExternal => _decoder.getBool(Key.IS_EXTERNAL);
 
   bool get isFromEnvironmentConstructor {
     return name == 'fromEnvironment' &&
-           library.isDartCore &&
-           (enclosingClass.name == 'bool' ||
+        library.isDartCore &&
+        (enclosingClass.name == 'bool' ||
             enclosingClass.name == 'int' ||
             enclosingClass.name == 'String');
   }
 
   ConstantConstructor get constantConstructor {
     if (isConst && _constantConstructor == null) {
       ObjectDecoder data =
           _decoder.getObject(Key.CONSTRUCTOR, isOptional: true);
       if (data == null) {
         assert(isFromEnvironmentConstructor || isExternal);
         return null;
       }
       _constantConstructor = ConstantConstructorDeserializer.deserialize(data);
     }
     return _constantConstructor;
   }
 
   @override
   AsyncMarker get asyncMarker => _unsupported('asyncMarker');
 
   @override
   InterfaceType computeEffectiveTargetType(InterfaceType newType) {
     return _unsupported('computeEffectiveTargetType');
   }
 
   @override
-  ConstructorElement get definingConstructor  {
+  ConstructorElement get definingConstructor {
     return _unsupported('definingConstructor');
   }
 
   @override
-  ConstructorElement get effectiveTarget  {
+  ConstructorElement get effectiveTarget {
     return _unsupported('effectiveTarget');
   }
 
   @override
-  ConstructorElement get immediateRedirectionTarget  {
+  ConstructorElement get immediateRedirectionTarget {
     return _unsupported('immediateRedirectionTarget');
   }
 
   @override
   bool get isEffectiveTargetMalformed {
     return _unsupported('isEffectiveTargetMalformed');
   }
 
   @override
   bool get isRedirectingFactory => _unsupported('isRedirectingFactory');
 
   @override
   bool get isRedirectingGenerative => _unsupported('isRedirectingGenerative');
 
   @override
   bool get isCyclicRedirection => _unsupported('isCyclicRedirection');
 
   @override
-  PrefixElement get redirectionDeferredPrefix  {
+  PrefixElement get redirectionDeferredPrefix {
     return _unsupported('redirectionDeferredPrefix');
   }
 }
 
 class GenerativeConstructorElementZ extends ConstructorElementZ {
-  GenerativeConstructorElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  GenerativeConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
 
   @override
   bool get isEffectiveTargetMalformed =>
       _unsupported('isEffectiveTargetMalformed');
 }
 
 class FactoryConstructorElementZ extends ConstructorElementZ {
-
-  FactoryConstructorElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  FactoryConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FACTORY_CONSTRUCTOR;
 
   @override
   bool get isEffectiveTargetMalformed =>
       _unsupported('isEffectiveTargetMalformed');
 }
 
 class ForwardingConstructorElementZ extends ElementZ
-    with AnalyzableElementMixin,
-        AstElementMixin
+    with AnalyzableElementMixin, AstElementMixin
     implements ConstructorElement {
   final MixinApplicationElement enclosingClass;
   final ConstructorElement definingConstructor;
 
   ForwardingConstructorElementZ(this.enclosingClass, this.definingConstructor);
 
   @override
   CompilationUnitElement get compilationUnit => enclosingClass.compilationUnit;
 
   @override
@@ skipping 23 matching lines @@
 
   @override
   Element get enclosingElement => enclosingClass;
 
   @override
   FunctionSignature get functionSignature {
     return _unsupported('functionSignature');
   }
 
   @override
-  bool get hasFunctionSignature  {
+  bool get hasFunctionSignature {
     return _unsupported('hasFunctionSignature');
   }
 
   @override
   ConstructorElement get immediateRedirectionTarget => null;
 
   @override
   bool get isCyclicRedirection => false;
 
   @override
@@ skipping 46 matching lines @@
   @override
   FunctionType get type {
     // TODO(johnniwinther): Ensure that the function type substitutes type
     // variables correctly.
     return definingConstructor.type;
   }
 }
 
 abstract class MemberElementMixin
     implements DeserializedElementZ, MemberElement {
-
   @override
   MemberElement get memberContext => this;
 
   @override
   Name get memberName => new Name(name, library);
 
   @override
   List<FunctionElement> get nestedClosures => const <FunctionElement>[];
-
 }
 
 abstract class FieldElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         TypedElementMixin,
-         MemberElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixin,
+        TypedElementMixin,
+        MemberElementMixin
     implements FieldElement {
   ConstantExpression _constant;
 
-  FieldElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  FieldElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FIELD;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitFieldElement(this, arg);
   }
 
   @override
   bool get isFinal => _decoder.getBool(Key.IS_FINAL);
 
   @override
   bool get isConst => _decoder.getBool(Key.IS_CONST);
 
   @override
   ConstantExpression get constant {
     if (isConst && _constant == null) {
       _constant = _decoder.getConstant(Key.CONSTANT);
     }
     return _constant;
   }
 
   @override
   Expression get initializer => _unsupported('initializer');
 }
 
-
 class TopLevelFieldElementZ extends FieldElementZ with LibraryMemberMixin {
-  TopLevelFieldElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  TopLevelFieldElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticFieldElementZ extends FieldElementZ
     with ClassMemberMixin, StaticMemberMixin {
-  StaticFieldElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  StaticFieldElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class InstanceFieldElementZ extends FieldElementZ
     with ClassMemberMixin, InstanceMemberMixin {
-  InstanceFieldElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  InstanceFieldElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 abstract class FunctionElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         ParametersMixin,
-         FunctionTypedElementMixin,
-         TypedElementMixin,
-         MemberElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixin,
+        ParametersMixin,
+        FunctionTypedElementMixin,
+        TypedElementMixin,
+        MemberElementMixin
     implements MethodElement {
-  FunctionElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  FunctionElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
   }
 
   @override
   bool get isOperator => _decoder.getBool(Key.IS_OPERATOR);
 }
 
 class TopLevelFunctionElementZ extends FunctionElementZ
     with LibraryMemberMixin {
-  TopLevelFunctionElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  TopLevelFunctionElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticFunctionElementZ extends FunctionElementZ
     with ClassMemberMixin, StaticMemberMixin {
-  StaticFunctionElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  StaticFunctionElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class InstanceFunctionElementZ extends FunctionElementZ
     with ClassMemberMixin, InstanceMemberMixin {
-  InstanceFunctionElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  InstanceFunctionElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 abstract class LocalExecutableMixin
     implements DeserializedElementZ, ExecutableElement, LocalElement {
   ExecutableElement _executableContext;
 
   @override
   Element get enclosingElement => executableContext;
 
   @override
@@ skipping 19 matching lines @@
   }
 
   @override
   bool get hasTreeElements => memberContext.hasTreeElements;
 
   @override
   TreeElements get treeElements => memberContext.treeElements;
 }
 
 class LocalFunctionElementZ extends DeserializedElementZ
-    with LocalExecutableMixin,
-         AstElementMixin,
-         ParametersMixin,
-         FunctionTypedElementMixin,
-         TypedElementMixin
+    with
+        LocalExecutableMixin,
+        AstElementMixin,
+        ParametersMixin,
+        FunctionTypedElementMixin,
+        TypedElementMixin
     implements LocalFunctionElement {
-  LocalFunctionElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  LocalFunctionElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitLocalFunctionElement(this, arg);
   }
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 }
 
 abstract class GetterElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         FunctionTypedElementMixin,
-         ParametersMixin,
-         TypedElementMixin,
-         MemberElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixin,
+        FunctionTypedElementMixin,
+        ParametersMixin,
+        TypedElementMixin,
+        MemberElementMixin
     implements GetterElement {
-
   AbstractFieldElement abstractField;
   SetterElement setter;
 
-  GetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  GetterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GETTER;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitGetterElement(this, arg);
   }
 }
 
 class TopLevelGetterElementZ extends GetterElementZ with LibraryMemberMixin {
-  TopLevelGetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  TopLevelGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticGetterElementZ extends GetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
-  StaticGetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  StaticGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class InstanceGetterElementZ extends GetterElementZ
     with ClassMemberMixin, InstanceMemberMixin {
-  InstanceGetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  InstanceGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 abstract class SetterElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         FunctionTypedElementMixin,
-         ParametersMixin,
-         TypedElementMixin,
-         MemberElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixin,
+        FunctionTypedElementMixin,
+        ParametersMixin,
+        TypedElementMixin,
+        MemberElementMixin
     implements SetterElement {
-
   AbstractFieldElement abstractField;
   GetterElement getter;
 
-  SetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  SetterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.SETTER;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitSetterElement(this, arg);
   }
 }
 
 class TopLevelSetterElementZ extends SetterElementZ with LibraryMemberMixin {
-  TopLevelSetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  TopLevelSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticSetterElementZ extends SetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
-  StaticSetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  StaticSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class InstanceSetterElementZ extends SetterElementZ
     with ClassMemberMixin, InstanceMemberMixin {
-  InstanceSetterElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  InstanceSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 abstract class TypeDeclarationMixin<T extends GenericType>
     implements ElementZ, TypeDeclarationElement {
   List<DartType> _typeVariables;
   T _rawType;
   T _thisType;
   Name _memberName;
 
   Name get memberName {
@@ skipping 35 matching lines @@
   }
 
   @override
   T computeType(Resolution resolution) => thisType;
 
   @override
   bool get isResolved => true;
 }
 
 class TypedefElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         LibraryMemberMixin,
-         ParametersMixin,
-         TypeDeclarationMixin<TypedefType>
+    with
+        AnalyzableElementMixin,
+        AstElementMixin,
+        LibraryMemberMixin,
+        ParametersMixin,
+        TypeDeclarationMixin<TypedefType>
     implements TypedefElement {
   DartType _alias;
 
-  TypedefElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  TypedefElementZ(ObjectDecoder decoder) : super(decoder);
 
   TypedefType _createType(List<DartType> typeArguments) {
     return new TypedefType(this, typeArguments);
   }
 
   @override
   List<DartType> _getTypeVariables() {
     return _decoder.getTypes(Key.TYPE_VARIABLES, isOptional: true);
   }
 
@@ skipping 14 matching lines @@
   }
 
   @override
   void ensureResolved(Resolution resolution) {}
 
   @override
   void checkCyclicReference(Resolution resolution) {}
 }
 
 class TypeVariableElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         TypedElementMixin
+    with AnalyzableElementMixin, AstElementMixin, TypedElementMixin
     implements TypeVariableElement {
   TypeDeclarationElement _typeDeclaration;
   TypeVariableType _type;
   DartType _bound;
   Name _memberName;
 
-  TypeVariableElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  TypeVariableElementZ(ObjectDecoder decoder) : super(decoder);
 
   Name get memberName {
     if (_memberName == null) {
       _memberName = new Name(name, library);
     }
     return _memberName;
   }
 
   @override
   ElementKind get kind => ElementKind.TYPE_VARIABLE;
@@ skipping 13 matching lines @@
 
   @override
   Element get enclosingClass => typeDeclaration;
 
   @override
   int get index => _decoder.getInt(Key.INDEX);
 
   @override
   TypeDeclarationElement get typeDeclaration {
     if (_typeDeclaration == null) {
-      _typeDeclaration =
-          _decoder.getElement(Key.TYPE_DECLARATION);
+      _typeDeclaration = _decoder.getElement(Key.TYPE_DECLARATION);
     }
     return _typeDeclaration;
   }
 
   DartType get bound {
     if (_bound == null) {
       _bound = _decoder.getType(Key.BOUND);
     }
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 }
 
 class SyntheticTypeVariableElementZ extends ElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin
+    with AnalyzableElementMixin, AstElementMixin
     implements TypeVariableElement {
   final TypeDeclarationElement typeDeclaration;
   final int index;
   final String name;
   TypeVariableType _type;
   DartType _bound;
   Name _memberName;
 
   SyntheticTypeVariableElementZ(this.typeDeclaration, this.index, this.name);
 
@@ skipping 13 matching lines @@
   }
 
   @override
   CompilationUnitElement get compilationUnit {
     return typeDeclaration.compilationUnit;
   }
 
   @override
   TypeVariableType get type {
     assert(invariant(this, _type != null,
-         message: "Type variable type has not been set on $this."));
+        message: "Type variable type has not been set on $this."));
     return _type;
   }
 
   @override
   TypeVariableType computeType(Resolution resolution) => type;
 
   @override
   Element get enclosingElement => typeDeclaration;
 
   @override
   Element get enclosingClass => typeDeclaration;
 
   DartType get bound {
     assert(invariant(this, _bound != null,
         message: "Type variable bound has not been set on $this."));
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 
   @override
   SourceSpan get sourcePosition => typeDeclaration.sourcePosition;
 }
 
 class ParameterElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin,
-         AstElementMixin,
-         TypedElementMixin
+    with AnalyzableElementMixin, AstElementMixin, TypedElementMixin
     implements ParameterElement {
   FunctionElement _functionDeclaration;
   ConstantExpression _constant;
   DartType _type;
 
   ParameterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitParameterElement(this, arg);
@@ skipping 48 matching lines @@
   LibraryElement get library => executableContext.library;
 
   @override
   MemberElement get memberContext => executableContext.memberContext;
 }
 
 class InitializingFormalElementZ extends ParameterElementZ
     implements InitializingFormalElement {
   FieldElement _fieldElement;
 
-  InitializingFormalElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  InitializingFormalElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   FieldElement get fieldElement {
     if (_fieldElement == null) {
       _fieldElement = _decoder.getElement(Key.FIELD);
     }
     return _fieldElement;
   }
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitFieldParameterElement(this, arg);
   }
 
   @override
   ElementKind get kind => ElementKind.INITIALIZING_FORMAL;
 }
 
 class ImportElementZ extends DeserializedElementZ
-    with LibraryMemberMixin implements ImportElement {
+    with LibraryMemberMixin
+    implements ImportElement {
   bool _isDeferred;
   PrefixElement _prefix;
   LibraryElement _importedLibrary;
   Uri _uri;
 
-  ImportElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  ImportElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   String get name => '';
 
   @override
   accept(ElementVisitor visitor, arg) => visitor.visitImportElement(this, arg);
 
   @override
   ElementKind get kind => ElementKind.IMPORT;
 
@@ skipping 32 matching lines @@
     return _uri;
   }
 
   @override
   Import get node => _unsupported('node');
 
   String toString() => 'Z$kind($uri)';
 }
 
 class ExportElementZ extends DeserializedElementZ
-    with LibraryMemberMixin implements ExportElement {
+    with LibraryMemberMixin
+    implements ExportElement {
   LibraryElement _exportedLibrary;
   Uri _uri;
 
-  ExportElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  ExportElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   String get name => '';
 
   @override
   accept(ElementVisitor visitor, arg) => visitor.visitExportElement(this, arg);
 
   @override
   ElementKind get kind => ElementKind.EXPORT;
 
@@ skipping 13 matching lines @@
     return _uri;
   }
 
   @override
   Export get node => _unsupported('node');
 
   String toString() => 'Z$kind($uri)';
 }
 
 class PrefixElementZ extends DeserializedElementZ
-    with LibraryMemberMixin implements PrefixElement {
+    with LibraryMemberMixin
+    implements PrefixElement {
   bool _isDeferred;
   ImportElement _deferredImport;
 
-  PrefixElementZ(ObjectDecoder decoder)
-      : super(decoder);
+  PrefixElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   accept(ElementVisitor visitor, arg) => visitor.visitPrefixElement(this, arg);
 
   void _ensureDeferred() {
     if (_isDeferred == null) {
       _isDeferred = _decoder.getBool(Key.IS_DEFERRED);
       _deferredImport = _decoder.getElement(Key.IMPORT, isOptional: true);
     }
   }
@@ skipping 11 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }