Run dartfmt on pkg/front_end/lib.

pkg/front_end/lib/src/fasta/source/outline_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.outline_builder;
 
-import 'package:kernel/ast.dart' show
-    AsyncMarker,
-    ProcedureKind;
+import 'package:kernel/ast.dart' show AsyncMarker, ProcedureKind;
 
-import '../parser/parser.dart' show
-    FormalParameterType,
-    optional;
+import '../parser/parser.dart' show FormalParameterType, optional;
 
-import '../scanner/token.dart' show
-    Token;
+import '../scanner/token.dart' show Token;
 
-import '../util/link.dart' show
-    Link;
+import '../util/link.dart' show Link;
 
-import '../combinator.dart' show
-    Combinator;
+import '../combinator.dart' show Combinator;
 
-import '../errors.dart' show
-    internalError;
+import '../errors.dart' show internalError;
 
 import '../builder/builder.dart';
 
-import '../modifier.dart' show
-    Modifier;
+import '../modifier.dart' show Modifier;
 
-import 'source_library_builder.dart' show
-    SourceLibraryBuilder;
+import 'source_library_builder.dart' show SourceLibraryBuilder;
 
-import 'unhandled_listener.dart' show
-    NullValue,
-    Unhandled,
-    UnhandledListener;
+import 'unhandled_listener.dart' show NullValue, Unhandled, UnhandledListener;
 
-import '../parser/error_kind.dart' show
-    ErrorKind;
+import '../parser/error_kind.dart' show ErrorKind;
 
-import '../parser/dart_vm_native.dart' show
-    removeNativeClause,
-    skipNativeClause;
+import '../parser/dart_vm_native.dart'
+    show removeNativeClause, skipNativeClause;
 
-import '../operator.dart' show
-    Operator,
-    operatorFromString,
-    operatorToString;
+import '../operator.dart' show Operator, operatorFromString, operatorToString;
 
-import '../quote.dart' show
-    unescapeString;
+import '../quote.dart' show unescapeString;
 
 enum MethodBody {
   Abstract,
   Regular,
   RedirectingFactoryBody,
 }
 
 AsyncMarker asyncMarkerFromTokens(Token asyncToken, Token starToken) {
   if (asyncToken == null || identical(asyncToken.stringValue, "sync")) {
     if (starToken == null) {
       return AsyncMarker.Sync;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.SyncStar;
     }
-  } else  if (identical(asyncToken.stringValue, "async")) {
+  } else if (identical(asyncToken.stringValue, "async")) {
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }
@@ skipping 13 matching lines @@
   Uri get uri => library.fileUri;
 
   @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
     List arguments = pop();
     String postfix = popIfNotNull(periodBeforeName);
     List<TypeBuilder> typeArguments = pop();
     if (arguments == null) {
       String expression = pop();
-      push(new MetadataBuilder.fromExpression(expression, postfix, library,
-              beginToken.charOffset));
+      push(new MetadataBuilder.fromExpression(
+          expression, postfix, library, beginToken.charOffset));
     } else {
       String typeName = pop();
       push(new MetadataBuilder.fromConstructor(
-               library.addConstructorReference(
-                   typeName, typeArguments, postfix,
-                   beginToken.next.charOffset),
-               arguments, library, beginToken.charOffset));
+          library.addConstructorReference(
+              typeName, typeArguments, postfix, beginToken.next.charOffset),
+          arguments,
+          library,
+          beginToken.charOffset));
     }
   }
 
   @override
   void endHide(Token hideKeyword) {
     debugEvent("Hide");
     List<String> names = pop();
     push(new Combinator.hide(names, hideKeyword.charOffset, library.fileUri));
   }
 
@@ skipping 24 matching lines @@
 
   @override
   void endImport(Token importKeyword, Token deferredKeyword, Token asKeyword,
       Token semicolon) {
     debugEvent("endImport");
     List<Combinator> combinators = pop();
     String prefix = popIfNotNull(asKeyword);
     Unhandled conditionalUris = pop();
     String uri = pop();
     List<MetadataBuilder> metadata = pop();
-    library.addImport(metadata, uri, conditionalUris, prefix, combinators,
-        deferredKeyword != null, importKeyword.charOffset,
+    library.addImport(
+        metadata,
+        uri,
+        conditionalUris,
+        prefix,
+        combinators,
+        deferredKeyword != null,
+        importKeyword.charOffset,
         asKeyword?.next?.charOffset ?? -1);
     checkEmpty(importKeyword.charOffset);
   }
 
   @override
   void endPart(Token partKeyword, Token semicolon) {
     debugEvent("Part");
     String uri = pop();
     List<MetadataBuilder> metadata = pop();
     library.addPart(metadata, uri);
@@ skipping 28 matching lines @@
     library.name = name;
     library.metadata = metadata;
   }
 
   @override
   void beginClassDeclaration(Token begin, Token name) {
     library.beginNestedDeclaration(name.value);
   }
 
   @override
-  void endClassDeclaration(int interfacesCount, Token beginToken,
-      Token classKeyword, Token extendsKeyword, Token implementsKeyword,
+  void endClassDeclaration(
+      int interfacesCount,
+      Token beginToken,
+      Token classKeyword,
+      Token extendsKeyword,
+      Token implementsKeyword,
       Token endToken) {
     debugEvent("endClassDeclaration");
     List<TypeBuilder> interfaces = popList(interfacesCount);
     TypeBuilder supertype = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     String name = pop();
     if (typeVariables != null && supertype is MixinApplicationBuilder) {
       supertype.typeVariables = typeVariables;
       supertype.subclassName = name;
     }
@@ skipping 10 matching lines @@
     if (optional("set", token)) return ProcedureKind.Setter;
     return internalError("Unhandled: ${token.value}");
   }
 
   @override
   void beginTopLevelMethod(Token token, Token name) {
     library.beginNestedDeclaration(name.value, hasMembers: false);
   }
 
   @override
-  void endTopLevelMethod(
-      Token beginToken, Token getOrSet, Token endToken) {
+  void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
     debugEvent("endTopLevelMethod");
     MethodBody kind = pop();
     AsyncMarker asyncModifier = pop();
     List<FormalParameterBuilder> formals = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     String name = pop();
     TypeBuilder returnType = pop();
-    int modifiers = Modifier.validate(pop(),
-        isAbstract: kind == MethodBody.Abstract);
+    int modifiers =
+        Modifier.validate(pop(), isAbstract: kind == MethodBody.Abstract);
     List<MetadataBuilder> metadata = pop();
     checkEmpty(beginToken.charOffset);
-    library.addProcedure(metadata, modifiers, returnType, name,
-        typeVariables, formals, asyncModifier, computeProcedureKind(getOrSet),
-        beginToken.charOffset, nativeMethodName, isTopLevel: true);
+    library.addProcedure(
+        metadata,
+        modifiers,
+        returnType,
+        name,
+        typeVariables,
+        formals,
+        asyncModifier,
+        computeProcedureKind(getOrSet),
+        beginToken.charOffset,
+        nativeMethodName,
+        isTopLevel: true);
     nativeMethodName = null;
   }
 
   @override
   void handleNoFunctionBody(Token token) {
     debugEvent("NoFunctionBody");
     push(MethodBody.Abstract);
   }
 
   @override
@@ skipping 25 matching lines @@
     String name;
     ProcedureKind kind;
     if (nameOrOperator is Operator) {
       name = operatorToString(nameOrOperator);
       kind = ProcedureKind.Operator;
     } else {
       name = nameOrOperator;
       kind = computeProcedureKind(getOrSet);
     }
     TypeBuilder returnType = pop();
-    int modifiers = Modifier.validate(pop(),
-        isAbstract: bodyKind == MethodBody.Abstract);
+    int modifiers =
+        Modifier.validate(pop(), isAbstract: bodyKind == MethodBody.Abstract);
     List<MetadataBuilder> metadata = pop();
     library.addProcedure(metadata, modifiers, returnType, name, typeVariables,
         formals, asyncModifier, kind, beginToken.charOffset, nativeMethodName,
         isTopLevel: false);
     nativeMethodName = null;
   }
 
   @override
   void endMixinApplication() {
     debugEvent("MixinApplication");
     List<TypeBuilder> mixins = pop();
     TypeBuilder supertype = pop();
     push(library.addMixinApplication(supertype, mixins, -1));
   }
 
   @override
   void beginNamedMixinApplication(Token begin, Token name) {
     library.beginNestedDeclaration(name.value, hasMembers: false);
   }
 
   @override
-  void endNamedMixinApplication(
-      Token beginToken, Token classKeyword, Token equals,
-      Token implementsKeyword, Token endToken) {
+  void endNamedMixinApplication(Token beginToken, Token classKeyword,
+      Token equals, Token implementsKeyword, Token endToken) {
     debugEvent("endNamedMixinApplication");
     List<TypeBuilder> interfaces = popIfNotNull(implementsKeyword);
     TypeBuilder mixinApplication = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     String name = pop();
     if (typeVariables != null && mixinApplication is MixinApplicationBuilder) {
       mixinApplication.typeVariables = typeVariables;
       mixinApplication.subclassName = name;
     }
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
-    library.addNamedMixinApplication(
-        metadata, name, typeVariables, modifiers, mixinApplication, interfaces,
-        beginToken.charOffset);
+    library.addNamedMixinApplication(metadata, name, typeVariables, modifiers,
+        mixinApplication, interfaces, beginToken.charOffset);
     checkEmpty(beginToken.charOffset);
   }
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
     push(popList(count) ?? NullValue.TypeArguments);
   }
 
   @override
@@ skipping 16 matching lines @@
     push(popList(count) ?? NullValue.TypeVariables);
   }
 
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(library.addVoidType(token.charOffset));
   }
 
   @override
-  void endFormalParameter(Token covariantKeyword, Token thisKeyword,
-      FormalParameterType kind) {
+  void endFormalParameter(
+      Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
     debugEvent("FormalParameter");
     String name = pop();
     TypeBuilder type = pop();
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
     // TODO(ahe): Needs begin token.
     push(library.addFormalParameter(metadata, modifiers, type, name,
-             thisKeyword != null, thisKeyword?.charOffset ?? -1));
+        thisKeyword != null, thisKeyword?.charOffset ?? -1));
   }
 
   @override
   void handleValuedFormalParameter(Token equals, Token token) {
     debugEvent("ValuedFormalParameter");
     // Ignored for now.
   }
 
   @override
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
     // Ignored for now.
   }
 
   @override
-  void endFunctionTypedFormalParameter(Token covariantKeyword,
-      Token thisKeyword, FormalParameterType kind) {
+  void endFunctionTypedFormalParameter(
+      Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
     debugEvent("FunctionTypedFormalParameter");
     pop(); // Function type parameters.
     pop(); // Type variables.
     String name = pop();
     pop(); // Return type.
     push(NullValue.Type);
     push(name);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
-        ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
+        ? FormalParameterType.NAMED
+        : FormalParameterType.POSITIONAL;
     List parameters = popList(count);
     for (FormalParameterBuilder parameter in parameters) {
       parameter.kind = kind;
     }
     push(parameters);
   }
 
   @override
   void endFormalParameters(int count, Token beginToken, Token endToken) {
     debugEvent("FormalParameters");
@@ skipping 41 matching lines @@
 
   @override
   void endFunctionTypeAlias(
       Token typedefKeyword, Token equals, Token endToken) {
     debugEvent("endFunctionTypeAlias");
     List<FormalParameterBuilder> formals = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     String name = pop();
     TypeBuilder returnType = pop();
     List<MetadataBuilder> metadata = pop();
-    library.addFunctionTypeAlias(
-        metadata, returnType, name, typeVariables, formals,
-        typedefKeyword.charOffset);
+    library.addFunctionTypeAlias(metadata, returnType, name, typeVariables,
+        formals, typedefKeyword.charOffset);
     checkEmpty(typedefKeyword.charOffset);
   }
 
   @override
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("endTopLevelFields");
     List<String> names = popList(count);
     TypeBuilder type = pop();
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
@@ skipping 28 matching lines @@
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference");
     String suffix = popIfNotNull(periodBeforeName);
     List<TypeBuilder> typeArguments = pop();
     String name = pop();
     push(library.addConstructorReference(
-            name, typeArguments, suffix, start.charOffset));
+        name, typeArguments, suffix, start.charOffset));
   }
 
   @override
   void beginFactoryMethod(Token token) {
     library.beginNestedDeclaration(null, hasMembers: false);
   }
 
   @override
   void endFactoryMethod(Token beginToken, Token endToken) {
     debugEvent("FactoryMethod");
@@ skipping 85 matching lines @@
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!isDartLibrary || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }