dartfmt pkg/compiler

pkg/compiler/lib/src/common/backend_api.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.
 
 library dart2js.backend_api;
 
 import 'dart:async' show Future;
 
 import '../common.dart';
-import '../common/codegen.dart' show
-    CodegenImpact;
-import '../common/resolution.dart' show
-    ResolutionImpact;
-import '../compiler.dart' show
-    Compiler;
-import '../compile_time_constants.dart' show
-    BackendConstantEnvironment,
-    ConstantCompilerTask;
-import '../constants/expressions.dart' show
-    ConstantExpression;
-import '../constants/constant_system.dart' show
-    ConstantSystem;
-import '../constants/values.dart' show
-    ConstantValue;
-import '../dart_types.dart' show
-    DartType,
-    InterfaceType;
-import '../elements/elements.dart' show
-    ClassElement,
-    ConstructorElement,
-    Element,
-    FunctionElement,
-    LibraryElement,
-    MetadataAnnotation,
-    MethodElement;
-import '../enqueue.dart' show
-    Enqueuer,
-    CodegenEnqueuer,
-    ResolutionEnqueuer;
-import '../io/code_output.dart' show
-    CodeBuffer;
-import '../io/source_information.dart' show
-    SourceInformationStrategy;
-import '../js_backend/backend_helpers.dart' as js_backend show
-    BackendHelpers;
-import '../js_backend/js_backend.dart' as js_backend show
-    JavaScriptBackend;
-import '../library_loader.dart' show
-    LibraryLoader,
-    LoadedLibraries;
-import '../native/native.dart' as native show
-    NativeEnqueuer,
-    maybeEnableNative;
-import '../patch_parser.dart' show
-    checkNativeAnnotation, checkJsInteropAnnotation;
-import '../resolution/tree_elements.dart' show
-    TreeElements;
-import '../serialization/serialization.dart' show
-    DeserializerPlugin,
-    ObjectDecoder,
-    ObjectEncoder,
-    SerializerPlugin;
-import '../tree/tree.dart' show
-    Node,
-    Send;
-import '../universe/call_structure.dart' show
-    CallStructure;
-import '../universe/world_impact.dart' show
-    ImpactStrategy,
-    WorldImpact;
+import '../common/codegen.dart' show CodegenImpact;
+import '../common/resolution.dart' show ResolutionImpact;
+import '../compiler.dart' show Compiler;
+import '../compile_time_constants.dart'
+    show BackendConstantEnvironment, ConstantCompilerTask;
+import '../constants/expressions.dart' show ConstantExpression;
+import '../constants/constant_system.dart' show ConstantSystem;
+import '../constants/values.dart' show ConstantValue;
+import '../dart_types.dart' show DartType, InterfaceType;
+import '../elements/elements.dart'
+    show
+        ClassElement,
+        ConstructorElement,
+        Element,
+        FunctionElement,
+        LibraryElement,
+        MetadataAnnotation,
+        MethodElement;
+import '../enqueue.dart' show Enqueuer, CodegenEnqueuer, ResolutionEnqueuer;
+import '../io/code_output.dart' show CodeBuffer;
+import '../io/source_information.dart' show SourceInformationStrategy;
+import '../js_backend/backend_helpers.dart' as js_backend show BackendHelpers;
+import '../js_backend/js_backend.dart' as js_backend show JavaScriptBackend;
+import '../library_loader.dart' show LibraryLoader, LoadedLibraries;
+import '../native/native.dart' as native show NativeEnqueuer, maybeEnableNative;
+import '../patch_parser.dart'
+    show checkNativeAnnotation, checkJsInteropAnnotation;
+import '../resolution/tree_elements.dart' show TreeElements;
+import '../serialization/serialization.dart'
+    show DeserializerPlugin, ObjectDecoder, ObjectEncoder, SerializerPlugin;
+import '../tree/tree.dart' show Node, Send;
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/world_impact.dart' show ImpactStrategy, WorldImpact;
 
-import 'codegen.dart' show
-    CodegenWorkItem;
-import 'registry.dart' show
-    Registry;
-import 'tasks.dart' show
-    CompilerTask;
-import 'work.dart' show
-    ItemCompilationContext;
-
+import 'codegen.dart' show CodegenWorkItem;
+import 'registry.dart' show Registry;
+import 'tasks.dart' show CompilerTask;
+import 'work.dart' show ItemCompilationContext;
 
 abstract class Backend {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   /// Returns true if the backend supports reflection.
   bool get supportsReflection;
 
   /// The [ConstantSystem] used to interpret compile-time constants for this
@@ skipping 34 matching lines @@
 
   void enqueueHelpers(ResolutionEnqueuer world, Registry registry);
 
   WorldImpact codegen(CodegenWorkItem work);
 
   // The backend determines the native resolution enqueuer, with a no-op
   // default, so tools like dart2dart can ignore the native classes.
   native.NativeEnqueuer nativeResolutionEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
+
   native.NativeEnqueuer nativeCodegenEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
 
   /// Generates the output and returns the total size of the generated code.
   int assembleProgram();
 
   List<CompilerTask> get tasks;
 
   void onResolutionComplete() {}
@@ skipping 13 matching lines @@
   /// Enable deferred loading. Returns `true` if the backend supports deferred
   /// loading.
   bool enableDeferredLoadingIfSupported(Spannable node, Registry registry);
 
   /// Called during codegen when [constant] has been used.
   void registerCompileTimeConstant(ConstantValue constant, Registry registry) {}
 
   /// Called during resolution when a constant value for [metadata] on
   /// [annotatedElement] has been evaluated.
   void registerMetadataConstant(MetadataAnnotation metadata,
-                                Element annotatedElement,
-                                Registry registry) {}
+      Element annotatedElement, Registry registry) {}
 
   /// Called to notify to the backend that a class is being instantiated.
   // TODO(johnniwinther): Remove this. It's only called once for each [cls] and
   // only with [Compiler.globalDependencies] as [registry].
-  void registerInstantiatedClass(ClassElement cls,
-                                 Enqueuer enqueuer,
-                                 Registry registry) {}
+  void registerInstantiatedClass(
+      ClassElement cls, Enqueuer enqueuer, Registry registry) {}
 
   /// Called to notify to the backend that a class is implemented by an
   /// instantiated class.
-  void registerImplementedClass(ClassElement cls,
-                                Enqueuer enqueuer,
-                                Registry registry) {}
+  void registerImplementedClass(
+      ClassElement cls, Enqueuer enqueuer, Registry registry) {}
 
   /// Called to instruct to the backend register [type] as instantiated on
   /// [enqueuer].
-  void registerInstantiatedType(InterfaceType type,
-                                Enqueuer enqueuer,
-                                Registry registry,
-                                {bool mirrorUsage: false}) {
+  void registerInstantiatedType(
+      InterfaceType type, Enqueuer enqueuer, Registry registry,
+      {bool mirrorUsage: false}) {
     registry.registerDependency(type.element);
     enqueuer.registerInstantiatedType(type, mirrorUsage: mirrorUsage);
   }
 
   /// Register a runtime type variable bound tests between [typeArgument] and
   /// [bound].
-  void registerTypeVariableBoundsSubtypeCheck(DartType typeArgument,
-                                              DartType bound) {}
+  void registerTypeVariableBoundsSubtypeCheck(
+      DartType typeArgument, DartType bound) {}
 
   /**
    * Call this to register that an instantiated generic class has a call
    * method.
    */
   void registerCallMethodWithFreeTypeVariables(
-      Element callMethod,
-      Enqueuer enqueuer,
-      Registry registry) {}
+      Element callMethod, Enqueuer enqueuer, Registry registry) {}
 
   /// Called to instruct the backend to register that a closure exists for a
   /// function on an instantiated generic class.
   void registerClosureWithFreeTypeVariables(
-      Element closure,
-      Enqueuer enqueuer,
-      Registry registry) {
+      Element closure, Enqueuer enqueuer, Registry registry) {
     enqueuer.universe.closuresWithFreeTypeVariables.add(closure);
   }
 
   /// Call this to register that a member has been closurized.
   void registerBoundClosure(Enqueuer enqueuer) {}
 
   /// Call this to register that a static function has been closurized.
   void registerGetOfStaticFunction(Enqueuer enqueuer) {}
 
   /**
@@ skipping 118 matching lines @@
   /// This method is called when all new libraries loaded through
   /// [LibraryLoader.loadLibrary] has been loaded and their imports/exports
   /// have been computed.
   Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     return new Future.value();
   }
 
   /// Called by [MirrorUsageAnalyzerTask] after it has merged all @MirrorsUsed
   /// annotations. The arguments corresponds to the unions of the corresponding
   /// fields of the annotations.
-  void registerMirrorUsage(Set<String> symbols,
-                           Set<Element> targets,
-                           Set<Element> metaTargets) {}
+  void registerMirrorUsage(
+      Set<String> symbols, Set<Element> targets, Set<Element> metaTargets) {}
 
   /// Returns true if this element needs reflection information at runtime.
   bool isAccessibleByReflection(Element element) => true;
 
   /// Returns true if this element is covered by a mirrorsUsed annotation.
   ///
   /// Note that it might still be ok to tree shake the element away if no
   /// reflection is used in the program (and thus [isTreeShakingDisabled] is
   /// still false). Therefore _do not_ use this predicate to decide inclusion
   /// in the tree, use [requiredByMirrorSystem] instead.
@@ skipping 47 matching lines @@
   FunctionElement helperForBadMain() => null;
 
   FunctionElement helperForMissingMain() => null;
 
   FunctionElement helperForMainArity() => null;
 
   void forgetElement(Element element) {}
 
   void registerMainHasArguments(Enqueuer enqueuer) {}
 
-  void registerAsyncMarker(FunctionElement element,
-                           Enqueuer enqueuer,
-                           Registry registry) {}
+  void registerAsyncMarker(
+      FunctionElement element, Enqueuer enqueuer, Registry registry) {}
 
   /// Called when resolving a call to a foreign function.
-  void registerForeignCall(Send node,
-                           Element element,
-                           CallStructure callStructure,
-                           ForeignResolver resolver) {}
+  void registerForeignCall(Send node, Element element,
+      CallStructure callStructure, ForeignResolver resolver) {}
 
   /// Returns the location of the patch-file associated with [libraryName]
   /// resolved from [plaformConfigUri].
   ///
   /// Returns null if there is none.
   Uri resolvePatchUri(String libraryName, Uri plaformConfigUri);
 
   /// Creates an impact strategy to use for compilation.
   ImpactStrategy createImpactStrategy(
       {bool supportDeferredLoad: true,
-       bool supportDumpInfo: true,
-       bool supportSerialization: true}) {
+      bool supportDumpInfo: true,
+      bool supportSerialization: true}) {
     return const ImpactStrategy();
   }
 }
 
 /// Interface for resolving calls to foreign functions.
 abstract class ForeignResolver {
   /// Returns the constant expression of [node], or `null` if [node] is not
   /// a constant expression.
   ConstantExpression getConstant(Node node);
 
@@ skipping 13 matching lines @@
   }
 
   /// Transform the [CodegenImpact] into a [WorldImpact] adding the
   /// backend dependencies for features used in [worldImpact].
   WorldImpact transformCodegenImpact(CodegenImpact worldImpact) {
     return worldImpact;
   }
 }
 
 /// Interface for serialization of backend specific data.
-class BackendSerialization  {
+class BackendSerialization {
   const BackendSerialization();
 
   SerializerPlugin get serializer => const SerializerPlugin();
   DeserializerPlugin get deserializer => const DeserializerPlugin();
 }