Refactor reifier to make it less dart_codegen specific.

lib/src/codegen/dart_codegen.dart

 // Copyright (c) 2015, 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 dev_compiler.src.codegen.dart_codegen;
 
 import 'dart:io' show File;
 
 import 'package:analyzer/analyzer.dart' as analyzer;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/java_core.dart' as java_core;
 import 'package:analyzer/src/generated/scanner.dart' show Token;
 import 'package:dart_style/dart_style.dart';
 import 'package:logging/logging.dart' as logger;
 import 'package:path/path.dart' as path;
 
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/utils.dart' as utils;
 import 'ast_builder.dart';
 import 'code_generator.dart' as codegenerator;
-import 'reify_coercions.dart' as reifier;
+import 'reify_coercions.dart' show CoercionReifier, NewTypeIdDesc;
 
 final _log = new logger.Logger('dev_compiler.dart_codegen');
 
 class DevCompilerRuntime {
   Identifier _runtimeId = AstBuilder.identifierFromString("DEVC\$RT");
 
   Identifier _castId;
   Identifier _typeToTypeId;
   Identifier _wrapId;
 
@@ skipping 82 matching lines @@
         s = d.format(s, uri: _path);
       } catch (e) {
         _log.severe("Failed to format $_path: " + e.toString());
       }
     }
     _log.fine("Writing file $_path");
     new File(_path).writeAsStringSync(s);
   }
 }
 
-bool _identifierNeedsQualification(
-    Identifier id, LibraryElement current, Set<Identifier> restrict) {
-  var element = id.bestElement;
-  return restrict.contains(id) &&
-      element != null &&
-      element.library != null &&
-      (element is ClassElement || element is FunctionTypeAliasElement) &&
-      !element.library.isDartCore &&
-      element.library != current;
-}
-
-// For every type name to which we add a reference, record the library from
-// which it comes so that we may add it to the list of imports.
-class UnitImportResolver extends analyzer.GeneralizingAstVisitor
-    with ConversionVisitor {
-  final CompilationUnit unit;
-  final Set<LibraryElement> imports;
-  final _currentLibrary;
-  final _newIdentifiers;
-
-  UnitImportResolver(
-      this.unit, this._currentLibrary, this.imports, this._newIdentifiers);
-
-  void compute() {
-    visitCompilationUnit(unit);
-    return;
-  }
-
-  @override
-  void visitCompilationUnit(CompilationUnit node) {
-    node.declarations.forEach((node) => node.accept(this));
-    return;
-  }
-
-  @override
-  void visitIdentifier(Identifier id) {

[Leaf, 2015/04/07 22:29:58]

All of this logic is now computed directly from the map returned by the coercion
reifier in computeExtraImports below.

-    if (id is PrefixedIdentifier) {
-      id.prefix.accept(this);
-      return;
-    }
-    if (_identifierNeedsQualification(id, _currentLibrary, _newIdentifiers)) {
-      if (utils.isDartPrivateLibrary(id.bestElement.library)) {
-        _log.severe(
-            "Dropping import of private library ${id.bestElement.library}\n");
-        return;
-      }
-      imports.add(id.bestElement.library);
-    }
-    return;
-  }
+bool _identifierNeedsQualification(Identifier id, NewTypeIdDesc desc) {
+  var library = desc.importedFrom;
+  if (library == null) return false;
+  if (library.isDartCore) return false;
+  if (desc.fromCurrent) return false;
+  return true;
 }
 
 // This class just holds some additional syntactic helpers and
 // fixes to the general ToSourceVisitor for use by subclasses.
 abstract class UnitGeneratorCommon extends analyzer.ToSourceVisitor {
   UnitGeneratorCommon(java_core.PrintWriter out) : super(out);
 
   void output(String s);
   void outputln(String s);
 
@@ skipping 82 matching lines @@
 }
 
 // TODO(leafp) Not sure if this is the right way to generate
 // Dart source going forward, but it's a quick way to get started.
 class UnitGenerator extends UnitGeneratorCommon with ConversionVisitor<Object> {
   CompilationUnit unit;
   final java_core.PrintWriter _out;
   final String outDir;
   Set<LibraryElement> _extraImports;
   final _runtime = new DevCompilerRuntime();
-  LibraryElement _currentLibrary;
   bool _qualifyNames = true;
-  Set<Identifier> _newIdentifiers;
+  Map<Identifier, NewTypeIdDesc> _newIdentifiers;
 
   UnitGenerator(this.unit, java_core.PrintWriter out, String this.outDir,
       this._extraImports, this._newIdentifiers)
       : _out = out,
-        super(out) {
-    _currentLibrary = unit.element.enclosingElement;
-    final UnitImportResolver r = new UnitImportResolver(
-        unit, _currentLibrary, _extraImports, _newIdentifiers);
-    r.compute();
-  }
+        super(out);
 
   void output(String s) => _out.print(s);
   void outputln(String s) => _out.println(s);
 
   // Choose a canonical prefix for a library that we are adding.
   // Currently just chooses something unlikely to conflict with a user
   // prefix.
   // TODO(leafp): Make this robust.
   String canonizeLibraryName(String name) {
     name = name.replaceAll(".", "DOT");
@@ skipping 81 matching lines @@
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier id) {
     safelyVisitNode(id.prefix);
     output('.');
     output(id.identifier.token.lexeme);
     return null;
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier id) {
-    var element = id.bestElement;
-    if (!(_qualifyNames &&
-        _identifierNeedsQualification(id, _currentLibrary, _newIdentifiers))) {
+    if (!(_qualifyNames
+          && _newIdentifiers.containsKey(id)
+          && _identifierNeedsQualification(id, _newIdentifiers[id]))) {
       return super.visitSimpleIdentifier(id);
     }
-    if (!utils.isDartPrivateLibrary(element.library)) {
-      var lib = utils.canonicalLibraryName(element.library);
+    var library = _newIdentifiers[id].importedFrom;
+    if (!utils.isDartPrivateLibrary(library)) {
+      var lib = utils.canonicalLibraryName(library);
       var libname = canonizeLibraryName(lib);
       output(libname);
       output('.');
     }
     output(id.name);
     return null;
   }
 
   void generate() {
     visitCompilationUnit(unit);
   }
 }
 
 class DartGenerator extends codegenerator.CodeGenerator {
   final CompilerOptions options;
-  reifier.VariableManager _vm;
-  Set<LibraryElement> _extraImports;
   TypeRules _rules;
 
   DartGenerator(String outDir, Uri root, TypeRules rules, this.options)
       : _rules = rules,
         super(outDir, root, rules);
 
-  void generateUnit(CompilationUnit unit, LibraryInfo info, String libraryDir) {

[Leaf, 2015/04/07 22:29:58]

This seemed kind of pointless as a separate function so I just folded it into
the body of the for loop in generateLibrary below.

[Jennifer Messerly, 2015/04/08 20:28:16]

+1, looks nice

-    var uri = unit.element.source.uri;
-    _log.fine("Generating unit " + uri.toString());
-    FileWriter out = new FileWriter(
-        options, path.join(libraryDir, '${uri.pathSegments.last}'));
-    var tm = new reifier.TypeManager(_vm);
-    var r = new reifier.UnitCoercionReifier(tm, _vm, _rules);
-    r.reify(unit);
-    var ids = new Set<Identifier>.from(tm.addedTypes.map((tn) => tn.name));
-    var unitGen = new UnitGenerator(unit, out, outDir, _extraImports, ids);
-    unitGen.generate();
-    out.finalize();
+  Set<LibraryElement> computeExtraImports(Map<Identifier, NewTypeIdDesc> ids) {
+    var imports = new Set<LibraryElement>();
+    void process(Identifier id, NewTypeIdDesc desc) {
+      if (_identifierNeedsQualification(id, desc)) {
+        var library = desc.importedFrom;
+        if (utils.isDartPrivateLibrary(library)) {
+          _log.severe(
+              "Dropping import of private library ${library}\n");
+          return;
+        }
+        imports.add(library);
+      }
+    }
+    ids.forEach(process);
+    return imports;
   }
 
   String generateLibrary(LibraryUnit library, LibraryInfo info) {
-    _vm = new reifier.VariableManager();
-    _extraImports = new Set<LibraryElement>();
+    var r = new CoercionReifier(library, rules);
+    var ids = r.reify();
+    var extraImports = computeExtraImports(ids);
 
     for (var unit in library.partsThenLibrary) {
-      var outputDir = makeOutputDirectory(info, unit);
-      generateUnit(unit, info, outputDir);
+      var libraryDir = makeOutputDirectory(info, unit);
+      var uri = unit.element.source.uri;
+      _log.fine("Generating unit " + uri.toString());

[Jennifer Messerly, 2015/04/08 20:28:16]

"Generating unit $uri" ?

+      FileWriter out = new FileWriter(
+          options, path.join(libraryDir, '${uri.pathSegments.last}'));
+      var unitGen = new UnitGenerator(unit, out, outDir, extraImports, ids);
+      unitGen.generate();
+      out.finalize();
     }
 
-    _extraImports = null;
-    _vm = null;
     return null;
   }
 }
 
 class EmptyUnitGenerator extends UnitGeneratorCommon {
   final java_core.PrintWriter _out;
   CompilationUnit unit;
 
   EmptyUnitGenerator(this.unit, java_core.PrintWriter out)
       : _out = out,
@@ skipping 25 matching lines @@
   void generateUnit(CompilationUnit unit, LibraryInfo info, String libraryDir) {
     var uri = unit.element.source.uri;
     _log.fine("Emitting original unit " + uri.toString());
     FileWriter out = new FileWriter(
         options, path.join(libraryDir, '${uri.pathSegments.last}'));
     var unitGen = new EmptyUnitGenerator(unit, out);
     unitGen.generate();
     out.finalize();
   }
 }