dartfmt pkg/compiler

pkg/compiler/lib/src/dart_backend/backend.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.
 
 part of dart_backend;
 
 // TODO(ahe): This class is simply wrong.  This backend should use
 // elements when it can, not AST nodes.  Perhaps a [Map<Element,
 // TreeElements>] is what is needed.
 class ElementAst {
@@ skipping 34 matching lines @@
   DartImpactTransformer impactTransformer;
 
   final Set<ClassElement> usedTypeLiterals = new Set<ClassElement>();
 
   /// The set of visible platform classes that are implemented by instantiated
   /// user classes.
   final Set<ClassElement> _userImplementedPlatformClasses =
       new Set<ClassElement>();
 
   bool enableCodegenWithErrorsIfSupported(Spannable node) {
-    reporter.reportHintMessage(
-        node,
-        MessageKind.GENERIC,
-        {'text': "Generation of code with compile time errors is not "
-                 "supported for dart2dart."});
+    reporter.reportHintMessage(node, MessageKind.GENERIC, {
+      'text': "Generation of code with compile time errors is not "
+          "supported for dart2dart."
+    });
     return false;
   }
 
   /**
    * Tells whether it is safe to remove type declarations from variables,
    * functions parameters. It becomes not safe if:
    * 1) TypeError is used somewhere in the code,
    * 2) The code has typedefs in right hand side of IS checks,
    * 3) The code has classes which extend typedefs, have type arguments typedefs
    *    or type variable bounds typedefs.
    * These restrictions can be less strict.
    */
   bool isSafeToRemoveTypeDeclarations(
       Map<ClassElement, Iterable<Element>> classMembers) {
     ClassElement typeErrorElement = compiler.coreLibrary.find('TypeError');
     if (classMembers.containsKey(typeErrorElement) ||
-        compiler.resolverWorld.isChecks.any(
-            (DartType type) => type.element == typeErrorElement)) {
+        compiler.resolverWorld.isChecks
+            .any((DartType type) => type.element == typeErrorElement)) {
       return false;
     }
     Set<DartType> processedTypes = new Set<DartType>();
     List<DartType> workQueue = new List<DartType>();
-    workQueue.addAll(
-        classMembers.keys.map((classElement) => classElement.thisType));
+    workQueue
+        .addAll(classMembers.keys.map((classElement) => classElement.thisType));
     workQueue.addAll(compiler.resolverWorld.isChecks);
 
     while (!workQueue.isEmpty) {
       DartType type = workQueue.removeLast();
       if (processedTypes.contains(type)) continue;
       processedTypes.add(type);
       if (type is FunctionType) return false;
       if (type is TypedefType) return false;
       if (type is InterfaceType) {
         InterfaceType interfaceType = type;
@@ skipping 15 matching lines @@
         constantCompilerTask = new DartConstantTask(compiler),
         outputter = new DartOutputter(
             compiler.reporter, compiler.outputProvider,
             forceStripTypes: strips.indexOf('types') != -1,
             multiFile: multiFile,
             enableMinification: compiler.options.enableMinification),
         super(compiler) {
     impactTransformer = new DartImpactTransformer(this);
   }
 
-
   DiagnosticReporter get reporter => compiler.reporter;
 
   Resolution get resolution => compiler.resolution;
 
   bool classNeedsRti(ClassElement cls) => false;
   bool methodNeedsRti(FunctionElement function) => false;
 
   void enqueueHelpers(ResolutionEnqueuer world, Registry registry) {
     // Right now resolver doesn't always resolve interfaces needed
     // for literals, so force them. TODO(antonm): fix in the resolver.
     final LITERAL_TYPE_NAMES = const [
-      'Map', 'List', 'num', 'int', 'double', 'bool'
+      'Map',
+      'List',
+      'num',
+      'int',
+      'double',
+      'bool'
     ];
     final coreLibrary = compiler.coreLibrary;
     for (final name in LITERAL_TYPE_NAMES) {
       ClassElement classElement = coreLibrary.findLocal(name);
       classElement.ensureResolved(resolution);
     }
     // Enqueue the methods that the VM might invoke on user objects because
     // we don't trust the resolution to always get these included.
     world.registerDynamicUse(new DynamicUse(Selectors.toString_, null));
-    world.registerDynamicUse(
-        new DynamicUse(Selectors.hashCode_, null));
+    world.registerDynamicUse(new DynamicUse(Selectors.hashCode_, null));
     world.registerDynamicUse(
         new DynamicUse(new Selector.binaryOperator('=='), null));
-    world.registerDynamicUse(
-        new DynamicUse(Selectors.compareTo, null));
+    world.registerDynamicUse(new DynamicUse(Selectors.compareTo, null));
   }
 
   WorldImpact codegen(CodegenWorkItem work) {
     return const WorldImpact();
   }
 
   /**
    * Tells whether we should output given element. Corelib classes like
    * Object should not be in the resulting code.
    */
   @override
   bool shouldOutput(Element element) {
     return (!element.library.isPlatformLibrary &&
             !element.isSynthesized &&
-            element is! AbstractFieldElement)
-        || mirrorRenamer.isMirrorHelperLibrary(element.library);
+            element is! AbstractFieldElement) ||
+        mirrorRenamer.isMirrorHelperLibrary(element.library);
   }
 
   int assembleProgram() {
     ElementAst computeElementAst(AstElement element) {
-      return new ElementAst(element.resolvedAst.node,
-                            element.resolvedAst.elements);
+      return new ElementAst(
+          element.resolvedAst.node, element.resolvedAst.elements);
     }
 
     // TODO(johnniwinther): Remove the need for this method.
-    void postProcessElementAst(
-        AstElement element, ElementAst elementAst,
-        newTypedefElementCallback,
-        newClassElementCallback) {
-      ReferencedElementCollector collector =
-          new ReferencedElementCollector(reporter,
-                                         element,
-                                         elementAst,
-                                         newTypedefElementCallback,
-                                         newClassElementCallback);
+    void postProcessElementAst(AstElement element, ElementAst elementAst,
+        newTypedefElementCallback, newClassElementCallback) {
+      ReferencedElementCollector collector = new ReferencedElementCollector(
+          reporter,
+          element,
+          elementAst,
+          newTypedefElementCallback,
+          newClassElementCallback);
       collector.collect();
     }
 
     int totalSize = outputter.assembleProgram(
         libraries: compiler.libraryLoader.libraries,
         instantiatedClasses: compiler.resolverWorld.directlyInstantiatedClasses,
         resolvedElements: compiler.enqueuer.resolution.processedElements,
         usedTypeLiterals: usedTypeLiterals,
         postProcessElementAst: postProcessElementAst,
         computeElementAst: computeElementAst,
         shouldOutput: shouldOutput,
         isSafeToRemoveTypeDeclarations: isSafeToRemoveTypeDeclarations,
         sortElements: Elements.sortedByPosition,
         mirrorRenamer: mirrorRenamer,
         mainFunction: compiler.mainFunction,
         outputUri: compiler.options.outputUri);
 
     // Output verbose info about size ratio of resulting bundle to all
     // referenced non-platform sources.
-    logResultBundleSizeInfo(
-        outputter.libraryInfo.userLibraries,
-        outputter.elementInfo.topLevelElements,
-        totalSize);
+    logResultBundleSizeInfo(outputter.libraryInfo.userLibraries,
+        outputter.elementInfo.topLevelElements, totalSize);
 
     return totalSize;
   }
 
   void logResultBundleSizeInfo(Iterable<LibraryElement> userLibraries,
-                               Iterable<Element> topLevelElements,
-                               int totalOutputSize) {
+      Iterable<Element> topLevelElements, int totalOutputSize) {
     // Sum total size of scripts in each referenced library.
     int nonPlatformSize = 0;
     for (LibraryElement lib in userLibraries) {
       for (CompilationUnitElement compilationUnit in lib.compilationUnits) {
         nonPlatformSize += compilationUnit.script.file.length;
       }
     }
     int percentage = totalOutputSize * 100 ~/ nonPlatformSize;
     log('Total used non-platform files size: ${nonPlatformSize} bytes, '
         'Output total size: $totalOutputSize bytes (${percentage}%)');
@@ skipping 10 matching lines @@
         library.forEachLocalMember((Element element) {
           if (element.isClass) {
             ClassElement classElement = element;
             classElement.ensureResolved(resolution);
           }
         });
       }
     });
     if (useMirrorHelperLibrary &&
         loadedLibraries.containsLibrary(Uris.dart_mirrors)) {
-      return compiler.libraryLoader.loadLibrary(
-          compiler.translateResolvedUri(
+      return compiler.libraryLoader
+          .loadLibrary(compiler.translateResolvedUri(
               loadedLibraries.getLibrary(Uris.dart_mirrors),
-              MirrorRenamerImpl.DART_MIRROR_HELPER, null)).
-          then((LibraryElement library) {
+              MirrorRenamerImpl.DART_MIRROR_HELPER,
+              null))
+          .then((LibraryElement library) {
         mirrorRenamer = new MirrorRenamerImpl(compiler, this, library);
       });
     }
     return new Future.value();
   }
 
   @override
   void registerStaticUse(Element element, Enqueuer enqueuer) {
     if (element == compiler.mirrorSystemGetNameFunction) {
       FunctionElement getNameFunction = mirrorRenamer.getNameFunction;
       if (getNameFunction != null) {
         enqueuer.addToWorkList(getNameFunction);
       }
     }
   }
 
   @override
-  void registerInstantiatedType(InterfaceType type,
-                                Enqueuer enqueuer,
-                                Registry registry,
-                                {bool mirrorUsage: false}) {
+  void registerInstantiatedType(
+      InterfaceType type, Enqueuer enqueuer, Registry registry,
+      {bool mirrorUsage: false}) {
     registerPlatformMembers(type, registerUse: registry.registerDynamicUse);
-    super.registerInstantiatedType(
-        type, enqueuer, registry, mirrorUsage: mirrorUsage);
+    super.registerInstantiatedType(type, enqueuer, registry,
+        mirrorUsage: mirrorUsage);
   }
 
   /// Register dynamic access of members of [type] that implement members
   /// of types defined in the platform libraries.
-  void registerPlatformMembers(
-      InterfaceType type,
+  void registerPlatformMembers(InterfaceType type,
       {void registerUse(DynamicUse dynamicUse)}) {
-
     // Without patching, dart2dart has no way of performing sound tree-shaking
     // in face external functions. Therefore we employ another scheme:
     //
     // Based on the assumption that the platform code only relies on the
     // interfaces of it's own classes, we can approximate the semantics of
     // external functions by eagerly registering dynamic invocation of instance
     // members defined the platform interfaces.
     //
     // Since we only need to generate code for non-platform classes we can
     // restrict this registration to platform interfaces implemented by
@@ skipping 14 matching lines @@
     // Here `MyRandom` is a subtype if `Random` defined in 'dart:math'. By the
     // assumption, all methods defined `Random` are potentially called, and
     // therefore, though there are no visible call sites from the user node,
     // dynamic invocation of for instance `nextInt` should be registered. In
     // this case, `nextInt` is actually called by the standard implementation of
     // `shuffle`.
 
     ClassElement cls = type.element;
     if (!cls.library.isPlatformLibrary) {
       for (Link<DartType> link = cls.allSupertypes;
-           !link.isEmpty;
-           link = link.tail) {
+          !link.isEmpty;
+          link = link.tail) {
         InterfaceType supertype = link.head;
         ClassElement superclass = supertype.element;
         LibraryElement library = superclass.library;
         if (library.isPlatformLibrary) {
           if (_userImplementedPlatformClasses.add(superclass)) {
             // Register selectors for all instance methods since these might
             // be called on user classes from within the platform
             // implementation.
             superclass.forEachLocalMember((MemberElement element) {
               if (element.isConstructor || element.isStatic) return;
 
               FunctionElement function = element.asFunctionElement();
               element.computeType(resolution);
               Selector selector = new Selector.fromElement(element);
-              registerUse(
-                  new DynamicUse(selector, null));
+              registerUse(new DynamicUse(selector, null));
             });
           }
         }
       }
     }
   }
 
   @override
   bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) {
     // TODO(sigurdm): Implement deferred loading for dart2dart.
@@ skipping 54 matching lines @@
 
   unparseFunctionName(Node name) {
     if (name != null && renames.containsKey(name)) {
       write(renames[name]);
     } else {
       super.unparseFunctionName(name);
     }
   }
 }
 
-
 /**
  * Some elements are not recorded by resolver now,
  * for example, typedefs or classes which are only
  * used in signatures, as/is operators or in super clauses
  * (just to name a few).  Retraverse AST to pick those up.
  */
 class ReferencedElementCollector extends Visitor {
   final DiagnosticReporter reporter;
   final Element element;
   final ElementAst elementAst;
   final newTypedefElementCallback;
   final newClassElementCallback;
 
-  ReferencedElementCollector(this.reporter,
-                             this.element,
-                             this.elementAst,
-                             this.newTypedefElementCallback,
-                             this.newClassElementCallback);
+  ReferencedElementCollector(this.reporter, this.element, this.elementAst,
+      this.newTypedefElementCallback, this.newClassElementCallback);
 
   visitNode(Node node) {
     node.visitChildren(this);
   }
 
   visitTypeAnnotation(TypeAnnotation typeAnnotation) {
     TreeElements treeElements = elementAst.treeElements;
     final DartType type = treeElements.getType(typeAnnotation);
     assert(invariant(typeAnnotation, type != null,
         message: "Missing type for type annotation: $treeElements."));
@@ skipping 25 matching lines @@
 
 /// [ConstantCompilerTask] for compilation of constants for the Dart backend.
 ///
 /// Since this task needs no distinction between frontend and backend constants
 /// it also serves as the [BackendConstantEnvironment].
 class DartConstantTask extends ConstantCompilerTask
     implements BackendConstantEnvironment {
   final DartConstantCompiler constantCompiler;
 
   DartConstantTask(Compiler compiler)
-    : this.constantCompiler = new DartConstantCompiler(compiler),
-      super(compiler);
+      : this.constantCompiler = new DartConstantCompiler(compiler),
+        super(compiler);
 
   String get name => 'ConstantHandler';
 
   @override
   ConstantSystem get constantSystem => constantCompiler.constantSystem;
 
   @override
   ConstantValue getConstantValue(ConstantExpression expression) {
     return constantCompiler.getConstantValue(expression);
   }
@@ skipping 38 matching lines @@
     });
   }
 
   void compileVariable(VariableElement element) {
     measure(() {
       constantCompiler.compileVariable(element);
     });
   }
 
   @override
-  ConstantExpression compileNode(
-      Node node,
-      TreeElements elements,
+  ConstantExpression compileNode(Node node, TreeElements elements,
       {bool enforceConst: true}) {
     return measure(() {
       return constantCompiler.compileNodeWithDefinitions(node, elements,
           isConst: enforceConst);
     });
   }
 
   @override
   ConstantExpression compileMetadata(
-      MetadataAnnotation metadata,
-      Node node,
-      TreeElements elements) {
+      MetadataAnnotation metadata, Node node, TreeElements elements) {
     return measure(() {
       return constantCompiler.compileMetadata(metadata, node, elements);
     });
   }
 
   // TODO(johnniwinther): Remove this when values are computed from the
   // expressions.
   @override
   void copyConstantValues(DartConstantTask task) {
-    constantCompiler.constantValueMap.addAll(
-        task.constantCompiler.constantValueMap);
+    constantCompiler.constantValueMap
+        .addAll(task.constantCompiler.constantValueMap);
   }
 }