Run dartfmt on pkg/front_end/lib.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart

 // Copyright (c) 2016, 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 fasta.kernel_procedure_builder;
 
-import 'package:kernel/ast.dart' show
-    Arguments,
-    AsyncMarker,
-    Constructor,
-    ConstructorInvocation,
-    DartType,
-    DynamicType,
-    EmptyStatement,
-    Expression,
-    FunctionNode,
-    Initializer,
-    Library,
-    LocalInitializer,
-    Member,
-    Name,
-    NamedExpression,
-    Procedure,
-    ProcedureKind,
-    RedirectingInitializer,
-    Statement,
-    StaticInvocation,
-    StringLiteral,
-    SuperInitializer,
-    TypeParameter,
-    VariableDeclaration,
-    VariableGet,
-    VoidType,
-    setParents;
+import 'package:kernel/ast.dart'
+    show
+        Arguments,
+        AsyncMarker,
+        Constructor,
+        ConstructorInvocation,
+        DartType,
+        DynamicType,
+        EmptyStatement,
+        Expression,
+        FunctionNode,
+        Initializer,
+        Library,
+        LocalInitializer,
+        Member,
+        Name,
+        NamedExpression,
+        Procedure,
+        ProcedureKind,
+        RedirectingInitializer,
+        Statement,
+        StaticInvocation,
+        StringLiteral,
+        SuperInitializer,
+        TypeParameter,
+        VariableDeclaration,
+        VariableGet,
+        VoidType,
+        setParents;
 
-import 'package:kernel/type_algebra.dart' show
-    containsTypeVariable,
-    substitute;
+import 'package:kernel/type_algebra.dart' show containsTypeVariable, substitute;
 
-import '../errors.dart' show
-    internalError;
+import '../errors.dart' show internalError;
 
-import '../messages.dart' show
-    warning;
+import '../messages.dart' show warning;
 
-import '../loader.dart' show
-    Loader;
+import '../loader.dart' show Loader;
 
-import 'kernel_builder.dart' show
-    Builder,
-    ClassBuilder,
-    ConstructorReferenceBuilder,
-    FormalParameterBuilder,
-    KernelFormalParameterBuilder,
-    KernelLibraryBuilder,
-    KernelTypeBuilder,
-    KernelTypeVariableBuilder,
-    MetadataBuilder,
-    ProcedureBuilder,
-    TypeVariableBuilder,
-    memberError;
+import 'kernel_builder.dart'
+    show
+        Builder,
+        ClassBuilder,
+        ConstructorReferenceBuilder,
+        FormalParameterBuilder,
+        KernelFormalParameterBuilder,
+        KernelLibraryBuilder,
+        KernelTypeBuilder,
+        KernelTypeVariableBuilder,
+        MetadataBuilder,
+        ProcedureBuilder,
+        TypeVariableBuilder,
+        memberError;
 
 abstract class KernelFunctionBuilder
     extends ProcedureBuilder<KernelTypeBuilder> {
   final String nativeMethodName;
 
   FunctionNode function;
 
   Statement actualBody;
 
-  KernelFunctionBuilder(List<MetadataBuilder> metadata, int modifiers,
-      KernelTypeBuilder returnType, String name,
+  KernelFunctionBuilder(
+      List<MetadataBuilder> metadata,
+      int modifiers,
+      KernelTypeBuilder returnType,
+      String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
-      KernelLibraryBuilder compilationUnit, int charOffset,
+      KernelLibraryBuilder compilationUnit,
+      int charOffset,
       this.nativeMethodName)
       : super(metadata, modifiers, returnType, name, typeVariables, formals,
-          compilationUnit, charOffset);
+            compilationUnit, charOffset);
 
   void set body(Statement newBody) {
     if (isAbstract && newBody != null) {
       return internalError("Attempting to set body on abstract method.");
     }
     actualBody = newBody;
     if (function != null) {
       function.body = newBody;
       newBody?.parent = function;
     }
@@ skipping 37 matching lines @@
           if (substitution == null) {
             substitution = <TypeParameter, DartType>{};
             for (TypeParameter parameter in typeParameters) {
               substitution[parameter] = const DynamicType();
             }
           }
           warning(fileUri, charOffset,
               "Can only use type variables in instance methods.");
           return substitute(type, substitution);
         }
+
         Set<TypeParameter> set = typeParameters.toSet();
         for (VariableDeclaration parameter in result.positionalParameters) {
           if (containsTypeVariable(parameter.type, set)) {
             parameter.type = removeTypeVariables(parameter.type);
           }
         }
         for (VariableDeclaration parameter in result.namedParameters) {
           if (containsTypeVariable(parameter.type, set)) {
             parameter.type = removeTypeVariables(parameter.type);
           }
         }
         if (containsTypeVariable(result.returnType, set)) {
           result.returnType = removeTypeVariables(result.returnType);
         }
       }
     }
     return function = result;
   }
 
   Member build(Library library);
 
   void becomeNative(Loader loader) {
     target.isExternal = true;
     Builder constructor = loader.getNativeAnnotation();
     Arguments arguments =
         new Arguments(<Expression>[new StringLiteral(nativeMethodName)]);
     Expression annotation;
     if (constructor.isConstructor) {
       annotation = new ConstructorInvocation(constructor.target, arguments)
-          ..isConst = true;
+        ..isConst = true;
     } else {
       annotation = new StaticInvocation(constructor.target, arguments)
-          ..isConst = true;
+        ..isConst = true;
     }
     target.addAnnotation(annotation);
   }
 }
 
 class KernelProcedureBuilder extends KernelFunctionBuilder {
   final Procedure procedure;
 
   AsyncMarker actualAsyncModifier;
 
   final ConstructorReferenceBuilder redirectionTarget;
 
   KernelProcedureBuilder(
       List<MetadataBuilder> metadata,
-      int modifiers, KernelTypeBuilder returnType, String name,
+      int modifiers,
+      KernelTypeBuilder returnType,
+      String name,
       List<TypeVariableBuilder> typeVariables,
-      List<FormalParameterBuilder> formals, this.actualAsyncModifier,
-      ProcedureKind kind, KernelLibraryBuilder compilationUnit, int charOffset,
-      [String nativeMethodName, this.redirectionTarget])
+      List<FormalParameterBuilder> formals,
+      this.actualAsyncModifier,
+      ProcedureKind kind,
+      KernelLibraryBuilder compilationUnit,
+      int charOffset,
+      [String nativeMethodName,
+      this.redirectionTarget])
       : procedure = new Procedure(null, kind, null,
             fileUri: compilationUnit?.relativeFileUri),
         super(metadata, modifiers, returnType, name, typeVariables, formals,
             compilationUnit, charOffset, nativeMethodName);
 
   ProcedureKind get kind => procedure.kind;
 
   AsyncMarker get asyncModifier => actualAsyncModifier;
 
   Statement get body {
-    if (actualBody == null && redirectionTarget == null && !isAbstract &&
+    if (actualBody == null &&
+        redirectionTarget == null &&
+        !isAbstract &&
         !isExternal) {
       actualBody = new EmptyStatement();
     }
     return actualBody;
   }
 
   void set asyncModifier(AsyncMarker newModifier) {
     actualAsyncModifier = newModifier;
     if (function != null) {
       // No parent, it's an enum.
@@ skipping 23 matching lines @@
   final Constructor constructor = new Constructor(null);
 
   bool hasMovedSuperInitializer = false;
 
   SuperInitializer superInitializer;
 
   RedirectingInitializer redirectingInitializer;
 
   KernelConstructorBuilder(
       List<MetadataBuilder> metadata,
-      int modifiers, KernelTypeBuilder returnType, String name,
+      int modifiers,
+      KernelTypeBuilder returnType,
+      String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
-      KernelLibraryBuilder compilationUnit, int charOffset,
+      KernelLibraryBuilder compilationUnit,
+      int charOffset,
       [String nativeMethodName])
       : super(metadata, modifiers, returnType, name, typeVariables, formals,
-          compilationUnit, charOffset, nativeMethodName);
+            compilationUnit, charOffset, nativeMethodName);
 
   bool get isInstanceMember => false;
 
   bool get isConstructor => true;
 
   AsyncMarker get asyncModifier => AsyncMarker.Sync;
 
   ProcedureKind get kind => null;
 
   Constructor build(Library library) {
     if (constructor.name == null) {
       constructor.function = buildFunction();
       constructor.function.parent = constructor;
       constructor.isConst = isConst;
       constructor.isExternal = isExternal;
       constructor.name = new Name(name, library);
     }
     return constructor;
   }
 
   FunctionNode buildFunction() {
     // TODO(ahe): Should complain if another type is explicitly set.
-    return super.buildFunction()
-        ..returnType = const VoidType();
+    return super.buildFunction()..returnType = const VoidType();
   }
 
   Constructor get target => constructor;
 
   void checkSuperOrThisInitializer(Initializer initializer) {
     if (superInitializer != null || redirectingInitializer != null) {
-      memberError(target,
+      memberError(
+          target,
           "Can't have more than one 'super' or 'this' initializer.",
           initializer.fileOffset);
     }
   }
 
   void addInitializer(Initializer initializer) {
     List<Initializer> initializers = constructor.initializers;
     if (initializer is SuperInitializer) {
       checkSuperOrThisInitializer(initializer);
       superInitializer = initializer;
@@ skipping 18 matching lines @@
         // To preserve correct evaluation order, the arguments to super call
         // must be evaluated before [initializer]. Once the super initializer
         // has been moved once, the arguments are evaluated in the correct
         // order.
         hasMovedSuperInitializer = true;
         Arguments arguments = superInitializer.arguments;
         List<Expression> positional = arguments.positional;
         for (int i = 0; i < positional.length; i++) {
           VariableDeclaration variable =
               new VariableDeclaration.forValue(positional[i], isFinal: true);
-          initializers.add(
-              new LocalInitializer(variable)..parent = constructor);
+          initializers
+              .add(new LocalInitializer(variable)..parent = constructor);
           positional[i] = new VariableGet(variable)..parent = arguments;
         }
         for (NamedExpression named in arguments.named) {
           VariableDeclaration variable =
               new VariableDeclaration.forValue(named.value, isFinal: true);
           named.value = new VariableGet(variable)..parent = named;
-          initializers.add(
-              new LocalInitializer(variable)..parent = constructor);
+          initializers
+              .add(new LocalInitializer(variable)..parent = constructor);
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }