dartfmt pkg/compiler

pkg/compiler/lib/src/js_backend/type_variable_handler.dart

 // Copyright (c) 2013, 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 js_backend;
 
 /**
  * Handles construction of TypeVariable constants needed at runtime.
  */
 class TypeVariableHandler {
@@ skipping 20 matching lines @@
       new Map<TypeVariableElement, jsAst.Expression>();
 
   TypeVariableHandler(this._compiler);
 
   ClassElement get _typeVariableClass => _backend.helpers.typeVariableClass;
   CodeEmitterTask get _task => _backend.emitter;
   MetadataCollector get _metadataCollector => _task.metadataCollector;
   JavaScriptBackend get _backend => _compiler.backend;
   DiagnosticReporter get reporter => _compiler.reporter;
 
-  void registerClassWithTypeVariables(ClassElement cls, Enqueuer enqueuer,
-                                      Registry registry) {
+  void registerClassWithTypeVariables(
+      ClassElement cls, Enqueuer enqueuer, Registry registry) {
     if (enqueuer.isResolutionQueue) {
       // On first encounter, we have to ensure that the support classes get
       // resolved.
       if (!_seenClassesWithTypeVariables) {
         _backend.enqueueClass(enqueuer, _typeVariableClass, registry);
         _typeVariableClass.ensureResolved(_compiler.resolution);
         Link constructors = _typeVariableClass.constructors;
         if (constructors.isEmpty && constructors.tail.isEmpty) {
           reporter.internalError(_typeVariableClass,
               "Class '$_typeVariableClass' should only have one constructor");
         }
         _typeVariableConstructor = _typeVariableClass.constructors.head;
         _backend.enqueueInResolution(_typeVariableConstructor, registry);
         _backend.registerInstantiatedType(
             _typeVariableClass.rawType, enqueuer, registry);
-        enqueuer.registerStaticUse(
-            new StaticUse.staticInvoke(
-                _backend.registerBackendUse(_backend.helpers.createRuntimeType),
-                CallStructure.ONE_ARG));
+        enqueuer.registerStaticUse(new StaticUse.staticInvoke(
+            _backend.registerBackendUse(_backend.helpers.createRuntimeType),
+            CallStructure.ONE_ARG));
         _seenClassesWithTypeVariables = true;
       }
     } else {
       if (_backend.isAccessibleByReflection(cls)) {
         processTypeVariablesOf(cls);
       }
     }
   }
 
   void processTypeVariablesOf(ClassElement cls) {
     // Do not process classes twice.
     if (_typeVariables.containsKey(cls)) return;
 
     InterfaceType typeVariableType = _typeVariableClass.thisType;
     List<jsAst.Expression> constants = <jsAst.Expression>[];
 
     for (TypeVariableType currentTypeVariable in cls.typeVariables) {
       TypeVariableElement typeVariableElement = currentTypeVariable.element;
 
       AstConstant name = new AstConstant(
           typeVariableElement,
           typeVariableElement.node,
           new StringConstantExpression(currentTypeVariable.name),
-          _backend.constantSystem.createString(
-              new DartString.literal(currentTypeVariable.name)));
+          _backend.constantSystem
+              .createString(new DartString.literal(currentTypeVariable.name)));
       jsAst.Expression boundIndex =
           _metadataCollector.reifyType(typeVariableElement.bound);
-      ConstantValue boundValue =
-          new SyntheticConstantValue(
-              SyntheticConstantKind.TYPEVARIABLE_REFERENCE,
-              boundIndex);
+      ConstantValue boundValue = new SyntheticConstantValue(
+          SyntheticConstantKind.TYPEVARIABLE_REFERENCE, boundIndex);
       ConstantExpression boundExpression =
           new SyntheticConstantExpression(boundValue);
-      AstConstant bound = new AstConstant(
-          typeVariableElement,
-          typeVariableElement.node,
-          boundExpression,
-          boundValue);
+      AstConstant bound = new AstConstant(typeVariableElement,
+          typeVariableElement.node, boundExpression, boundValue);
       AstConstant type = new AstConstant(
           typeVariableElement,
           typeVariableElement.node,
           new TypeConstantExpression(cls.rawType),
           _backend.constantSystem.createType(_backend.compiler, cls.rawType));
       List<AstConstant> arguments = [type, name, bound];
 
       // TODO(johnniwinther): Support a less front-end specific creation of
       // constructed constants.
       AstConstant constant =
           CompileTimeConstantEvaluator.makeConstructedConstant(
               _compiler,
               _backend.constants,
               typeVariableElement,
               typeVariableElement.node,
               typeVariableType,
               _typeVariableConstructor,
               typeVariableType,
               _typeVariableConstructor,
               const CallStructure.unnamed(3),
               arguments,
               arguments);
       ConstantValue value = constant.value;
       _backend.registerCompileTimeConstant(value, _compiler.globalDependencies);
       _backend.addCompileTimeConstantForEmission(value);
       _backend.constants.addCompileTimeConstantForEmission(value);
-      constants.add(
-          _reifyTypeVariableConstant(value, currentTypeVariable.element));
+      constants
+          .add(_reifyTypeVariableConstant(value, currentTypeVariable.element));
     }
     _typeVariables[cls] = constants;
   }
 
   /**
    * Adds [c] to [emitter.metadataCollector] and returns the index pointing to
    * the entry.
    *
    * If the corresponding type variable has already been encountered an
    * entry in the list has already been reserved and the constant is added
    * there, otherwise a new entry for [c] is created.
    */
-  jsAst.Expression _reifyTypeVariableConstant(ConstantValue c,
-                                              TypeVariableElement variable) {
+  jsAst.Expression _reifyTypeVariableConstant(
+      ConstantValue c, TypeVariableElement variable) {
     jsAst.Expression name = _task.constantReference(c);
     jsAst.Expression result = _metadataCollector.reifyExpression(name);
     if (_typeVariableConstants.containsKey(variable)) {
       Placeholder placeholder = _typeVariableConstants[variable];
       placeholder.bind(result);
     }
     _typeVariableConstants[variable] = result;
     return result;
   }
 
@@ skipping 18 matching lines @@
   }
 
   List<jsAst.Expression> typeVariablesOf(ClassElement classElement) {
     List<jsAst.Expression> result = _typeVariables[classElement];
     if (result == null) {
       result = const <jsAst.Expression>[];
     }
     return result;
   }
 }