dartfmt pkg/compiler

pkg/compiler/lib/src/mirrors_used.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.
 
 library dart2js.mirrors_used;
 
 import 'common.dart';
-import 'common/tasks.dart' show
-    CompilerTask;
-import 'compile_time_constants.dart' show
-    ConstantCompiler;
-import 'compiler.dart' show
-    Compiler;
+import 'common/tasks.dart' show CompilerTask;
+import 'compile_time_constants.dart' show ConstantCompiler;
+import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
-import 'constants/values.dart' show
-    ConstantValue,
-    ConstructedConstantValue,
-    ListConstantValue,
-    StringConstantValue,
-    TypeConstantValue;
-import 'dart_types.dart' show
-    DartType,
-    InterfaceType,
-    TypeKind;
-import 'elements/elements.dart' show
-    ClassElement,
-    Element,
-    ImportElement,
-    LibraryElement,
-    MetadataAnnotation,
-    ScopeContainerElement,
-    VariableElement;
-import 'resolution/tree_elements.dart' show
-    TreeElements;
-import 'tree/tree.dart' show
-    Import,
-    LibraryTag,
-    NamedArgument,
-    NewExpression,
-    Node;
+import 'constants/values.dart'
+    show
+        ConstantValue,
+        ConstructedConstantValue,
+        ListConstantValue,
+        StringConstantValue,
+        TypeConstantValue;
+import 'dart_types.dart' show DartType, InterfaceType, TypeKind;
+import 'elements/elements.dart'
+    show
+        ClassElement,
+        Element,
+        ImportElement,
+        LibraryElement,
+        MetadataAnnotation,
+        ScopeContainerElement,
+        VariableElement;
+import 'resolution/tree_elements.dart' show TreeElements;
+import 'tree/tree.dart'
+    show Import, LibraryTag, NamedArgument, NewExpression, Node;
 
 /**
  * Compiler task that analyzes MirrorsUsed annotations.
  *
  * When importing 'dart:mirrors', it is possible to annotate the import with
  * MirrorsUsed annotation.  This is a way to declare what elements will be
  * reflected on at runtime.  Such elements, even they would normally be
  * discarded by the implicit tree-shaking algorithm must be preserved in the
  * final output.
  *
@@ skipping 33 matching lines @@
  * MirrorsUsed annotation, these annotations are merged.
  *
  * MERGING MIRRORSUSED
  *
  * TBD.
  */
 class MirrorUsageAnalyzerTask extends CompilerTask {
   Set<LibraryElement> librariesWithUsage;
   MirrorUsageAnalyzer analyzer;
 
-  MirrorUsageAnalyzerTask(Compiler compiler)
-      : super(compiler) {
+  MirrorUsageAnalyzerTask(Compiler compiler) : super(compiler) {
     analyzer = new MirrorUsageAnalyzer(compiler, this);
   }
 
   /// Collect @MirrorsUsed annotations in all libraries.  Called by the
   /// compiler after all libraries are loaded, but before resolution.
   void analyzeUsage(LibraryElement mainApp) {
     if (mainApp == null || compiler.mirrorsLibrary == null) return;
     measure(analyzer.run);
     List<String> symbols = analyzer.mergedMirrorUsage.symbols;
     List<Element> targets = analyzer.mergedMirrorUsage.targets;
     List<Element> metaTargets = analyzer.mergedMirrorUsage.metaTargets;
     compiler.backend.registerMirrorUsage(
         symbols == null ? null : new Set<String>.from(symbols),
         targets == null ? null : new Set<Element>.from(targets),
         metaTargets == null ? null : new Set<Element>.from(metaTargets));
     librariesWithUsage = analyzer.librariesWithUsage;
   }
 
   /// Is there a @MirrorsUsed annotation in the library of [element]?  Used by
   /// the resolver to suppress hints about using new Symbol or
   /// MirrorSystem.getName.
   bool hasMirrorUsage(Element element) {
     LibraryElement library = element.library;
     // Internal libraries always have implicit mirror usage.
-    return library.isInternalLibrary
-        || (librariesWithUsage != null
-            && librariesWithUsage.contains(library));
+    return library.isInternalLibrary ||
+        (librariesWithUsage != null && librariesWithUsage.contains(library));
   }
 
   /// Call-back from the resolver to analyze MirorsUsed annotations. The result
   /// is stored in [analyzer] and later used to compute
   /// [:analyzer.mergedMirrorUsage:].
   void validate(NewExpression node, TreeElements mapping) {
     for (Node argument in node.send.arguments) {
       NamedArgument named = argument.asNamedArgument();
       if (named == null) continue;
       ConstantCompiler constantCompiler = compiler.resolver.constantCompiler;
-      ConstantValue value =
-          constantCompiler.getConstantValue(
-              constantCompiler.compileNode(named.expression, mapping));
+      ConstantValue value = constantCompiler.getConstantValue(
+          constantCompiler.compileNode(named.expression, mapping));
 
-      MirrorUsageBuilder builder =
-          new MirrorUsageBuilder(
-              analyzer, mapping.analyzedElement.library, named.expression,
-              value, mapping);
+      MirrorUsageBuilder builder = new MirrorUsageBuilder(analyzer,
+          mapping.analyzedElement.library, named.expression, value, mapping);
 
       if (named.name.source == 'symbols') {
         analyzer.cachedStrings[value] =
             builder.convertConstantToUsageList(value, onlyStrings: true);
       } else if (named.name.source == 'targets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'metaTargets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
@@ skipping 43 matching lines @@
 
   /// Collect all @MirrorsUsed from all libraries and represent them as
   /// [MirrorUsage].
   Map<LibraryElement, List<MirrorUsage>> collectMirrorsUsedAnnotation() {
     Map<LibraryElement, List<MirrorUsage>> result =
         new Map<LibraryElement, List<MirrorUsage>>();
     for (LibraryElement library in compiler.libraryLoader.libraries) {
       if (library.isInternalLibrary) continue;
       for (ImportElement import in library.imports) {
         reporter.withCurrentElement(library, () {
-          List<MirrorUsage> usages =
-              mirrorsUsedOnLibraryTag(library, import);
+          List<MirrorUsage> usages = mirrorsUsedOnLibraryTag(library, import);
           if (usages != null) {
             List<MirrorUsage> existing = result[library];
             if (existing != null) {
               existing.addAll(usages);
             } else {
               result[library] = usages;
             }
           }
         });
       }
@@ skipping 19 matching lines @@
           }
         } else {
           for (Element overridden in override) {
             List<MirrorUsage> overriddenUsages = propagatedOverrides
                 .putIfAbsent(overridden, () => <MirrorUsage>[]);
             overriddenUsages.add(usage);
           }
         }
       }
     });
-    propagatedOverrides.forEach((LibraryElement overridden,
-                                 List<MirrorUsage> overriddenUsages) {
+    propagatedOverrides.forEach(
+        (LibraryElement overridden, List<MirrorUsage> overriddenUsages) {
       List<MirrorUsage> usages =
           usageMap.putIfAbsent(overridden, () => <MirrorUsage>[]);
       usages.addAll(overriddenUsages);
     });
   }
 
   /// Find @MirrorsUsed annotations on the given import [tag] in [library]. The
   /// annotations are represented as [MirrorUsage].
-  List<MirrorUsage> mirrorsUsedOnLibraryTag(LibraryElement library,
-                                            ImportElement import) {
+  List<MirrorUsage> mirrorsUsedOnLibraryTag(
+      LibraryElement library, ImportElement import) {
     LibraryElement importedLibrary = import.importedLibrary;
     if (importedLibrary != compiler.mirrorsLibrary) {
       return null;
     }
     List<MirrorUsage> result = <MirrorUsage>[];
     for (MetadataAnnotation metadata in import.metadata) {
       metadata.ensureResolved(compiler.resolution);
       ConstantValue value =
           compiler.constants.getConstantValue(metadata.constant);
       Element element = value.getType(compiler.coreTypes).element;
@@ skipping 22 matching lines @@
     }
   }
 
   /// Merge [a] with [b]. The resulting [MirrorUsage] simply has the symbols,
   /// targets, and metaTargets of [a] and [b] concatenated. 'override' is
   /// ignored.
   MirrorUsage merge(MirrorUsage a, MirrorUsage b) {
     // TOOO(ahe): Should be an instance method on MirrorUsage.
     if (a.symbols == null && a.targets == null && a.metaTargets == null) {
       return b;
-    } else if (
-        b.symbols == null && b.targets == null && b.metaTargets == null) {
+    } else if (b.symbols == null &&
+        b.targets == null &&
+        b.metaTargets == null) {
       return a;
     }
     // TODO(ahe): Test the following cases.
     List<String> symbols = a.symbols;
     if (symbols == null) {
       symbols = b.symbols;
     } else if (b.symbols != null) {
       symbols.addAll(b.symbols);
     }
     List<Element> targets = a.targets;
     if (targets == null) {
       targets = b.targets;
     } else if (targets != wildcard && b.targets != null) {
       targets.addAll(b.targets);
     }
     List<Element> metaTargets = a.metaTargets;
     if (metaTargets == null) {
       metaTargets = b.metaTargets;
     } else if (metaTargets != wildcard && b.metaTargets != null) {
       metaTargets.addAll(b.metaTargets);
     }
     return new MirrorUsage(symbols, targets, metaTargets, null);
   }
 
   /// Convert a [constant] to an instance of [MirrorUsage] using information
   /// that was resolved during [MirrorUsageAnalyzerTask.validate].
   MirrorUsage buildUsage(ConstructedConstantValue constant) {
     Map<Element, ConstantValue> fields = constant.fields;
-    VariableElement symbolsField = compiler.mirrorsUsedClass.lookupLocalMember(
-        'symbols');
-    VariableElement targetsField = compiler.mirrorsUsedClass.lookupLocalMember(
-        'targets');
+    VariableElement symbolsField =
+        compiler.mirrorsUsedClass.lookupLocalMember('symbols');
+    VariableElement targetsField =
+        compiler.mirrorsUsedClass.lookupLocalMember('targets');
     VariableElement metaTargetsField =
-        compiler.mirrorsUsedClass.lookupLocalMember(
-            'metaTargets');
-    VariableElement overrideField = compiler.mirrorsUsedClass.lookupLocalMember(
-        'override');
+        compiler.mirrorsUsedClass.lookupLocalMember('metaTargets');
+    VariableElement overrideField =
+        compiler.mirrorsUsedClass.lookupLocalMember('override');
 
     return new MirrorUsage(
         cachedStrings[fields[symbolsField]],
         cachedElements[fields[targetsField]],
         cachedElements[fields[metaTargetsField]],
         cachedElements[fields[overrideField]]);
   }
 }
 
 /// Used to represent a resolved MirrorsUsed constant.
 class MirrorUsage {
   final List<String> symbols;
   final List<Element> targets;
   final List<Element> metaTargets;
   final List<Element> override;
 
   MirrorUsage(this.symbols, this.targets, this.metaTargets, this.override);
 
   String toString() {
-    return
-        'MirrorUsage('
+    return 'MirrorUsage('
         'symbols = $symbols, '
         'targets = $targets, '
         'metaTargets = $metaTargets, '
         'override = $override'
         ')';
-
   }
 }
 
 class MirrorUsageBuilder {
   final MirrorUsageAnalyzer analyzer;
   final LibraryElement enclosingLibrary;
   final Spannable spannable;
   final ConstantValue constant;
   final TreeElements elements;
 
-  MirrorUsageBuilder(
-      this.analyzer,
-      this.enclosingLibrary,
-      this.spannable,
-      this.constant,
-      this.elements);
+  MirrorUsageBuilder(this.analyzer, this.enclosingLibrary, this.spannable,
+      this.constant, this.elements);
 
   Compiler get compiler => analyzer.compiler;
 
   DiagnosticReporter get reporter => analyzer.reporter;
 
   /// Convert a constant to a list of [String] and [Type] values. If the
   /// constant is a single [String], it is assumed to be a comma-separated list
   /// of qualified names. If the constant is a [Type] t, the result is [:[t]:].
   /// Otherwise, the constant is assumed to represent a list of strings (each a
   /// qualified name) and types, and such a list is constructed.  If
   /// [onlyStrings] is true, the returned list is a [:List<String>:] and any
   /// [Type] values are treated as an error (meaning that the value is ignored
   /// and a hint is emitted).
-  List convertConstantToUsageList(
-      ConstantValue constant, { bool onlyStrings: false }) {
+  List convertConstantToUsageList(ConstantValue constant,
+      {bool onlyStrings: false}) {
     if (constant.isNull) {
       return null;
     } else if (constant.isList) {
       ListConstantValue list = constant;
-      List result = onlyStrings ? <String> [] : [];
+      List result = onlyStrings ? <String>[] : [];
       for (ConstantValue entry in list.entries) {
         if (entry.isString) {
           StringConstantValue string = entry;
           result.add(string.primitiveValue.slowToString());
         } else if (!onlyStrings && entry.isType) {
           TypeConstantValue type = entry;
           result.add(type.representedType);
         } else {
           Spannable node = positionOf(entry);
           MessageKind kind = onlyStrings
@@ skipping 25 matching lines @@
 
   /// Find the first non-implementation interface of constant.
   DartType apiTypeOf(ConstantValue constant) {
     DartType type = constant.getType(compiler.coreTypes);
     LibraryElement library = type.element.library;
     if (type.isInterfaceType && library.isInternalLibrary) {
       InterfaceType interface = type;
       ClassElement cls = type.element;
       cls.ensureResolved(compiler.resolution);
       for (DartType supertype in cls.allSupertypes) {
-        if (supertype.isInterfaceType
-            && !supertype.element.library.isInternalLibrary) {
+        if (supertype.isInterfaceType &&
+            !supertype.element.library.isInternalLibrary) {
           return interface.asInstanceOf(supertype.element);
         }
       }
     }
     return type;
   }
 
   /// Convert a list of strings and types to a list of elements. Types are
   /// converted to their corresponding element, and strings are resolved as
   /// follows:
@@ skipping 17 matching lines @@
         String libraryNameCandiate;
         for (LibraryElement l in compiler.libraryLoader.libraries) {
           if (l.hasLibraryName) {
             String libraryName = l.libraryOrScriptName;
             if (string == libraryName) {
               // Found an exact match.
               libraryCandiate = l;
               libraryNameCandiate = libraryName;
               break;
             } else if (string.startsWith('$libraryName.')) {
-              if (libraryNameCandiate == null
-                  || libraryNameCandiate.length < libraryName.length) {
+              if (libraryNameCandiate == null ||
+                  libraryNameCandiate.length < libraryName.length) {
                 // Found a better candiate
                 libraryCandiate = l;
                 libraryNameCandiate = libraryName;
               }
             }
           }
         }
         Element e;
         if (libraryNameCandiate == string) {
           e = libraryCandiate;
         } else if (libraryNameCandiate != null) {
-          e = resolveLocalExpression(
-              libraryCandiate,
+          e = resolveLocalExpression(libraryCandiate,
               string.substring(libraryNameCandiate.length + 1).split('.'));
         } else {
           e = resolveExpression(string);
         }
         if (e != null) result.add(e);
       }
     }
     return result;
   }
 
@@ skipping 15 matching lines @@
 
   /// Resolve [identifiers] in [element]'s local members.
   Element resolveLocalExpression(Element element, List<String> identifiers) {
     Element current = element;
     for (String identifier in identifiers) {
       Element e = findLocalMemberIn(current, identifier);
       if (e == null) {
         if (current.isLibrary) {
           LibraryElement library = current;
           reporter.reportHintMessage(
-              spannable, MessageKind.MIRRORS_CANNOT_RESOLVE_IN_LIBRARY,
-              {'name': identifiers[0],
-               'library': library.libraryOrScriptName});
+              spannable,
+              MessageKind.MIRRORS_CANNOT_RESOLVE_IN_LIBRARY,
+              {'name': identifiers[0], 'library': library.libraryOrScriptName});
         } else {
           reporter.reportHintMessage(
-              spannable, MessageKind.MIRRORS_CANNOT_FIND_IN_ELEMENT,
+              spannable,
+              MessageKind.MIRRORS_CANNOT_FIND_IN_ELEMENT,
               {'name': identifier, 'element': current.name});
         }
         return current;
       }
       current = e;
     }
     return current;
   }
 
   /// Helper method to lookup members in a [ScopeContainerElement]. If
@@ skipping 34 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }