anchor.diff:      var sourceFile = new SourceFile(
           entryPointFile.getAbsolutePath(),
           entryPointImport,
  -        resolvedUnit);
  +        resolvedUnit.element);
       List<SourceFile> visited = <SourceFile>[];
       List<SourceFile> toVisit = <SourceFile>[sourceFile];
   
  
positive.code:   return code.toString();
  }
  
  class CompilationUnitVisitor extends GeneralizingASTVisitor {
    List<String> imports;
    Map<String, String> typeToImport;
    List<ClassElement> typeFactoryTypes;
    List<String> classAnnotations;
    SourceFile source;
  
    CompilationUnitVisitor(this.source, this.classAnnotations, this.imports,
        this.typeToImport, this.typeFactoryTypes);
  
    visitLibraryDirective(LibraryDirective library) {
      LibraryElement libElement = library.element;
      int annotationIdx = 0;
      for (ElementAnnotation ann in libElement.metadata) {
        if (ann.element is ConstructorElement) {
          ConstructorElement con = ann.element;
          if (getQualifiedName(con.enclosingElement.type) == 'di.annotations.Injectables') {
            var listLiteral =
                library.metadata[annotationIdx].arguments.arguments.first;
            for (Expression element in listLiteral.elements) {
              typeFactoryTypes
                  .add((element as SimpleIdentifier).element as ClassElement);
            }
          }
        }
        annotationIdx++;
      }
      return super.visitLibraryDirective(library);
    }
  
    visitClassDeclaration(ClassDeclaration classDecl) {
      if (classDecl.name.name.startsWith('_')) {
        return; // ignore private classes.
      }
      typeToImport[getCanonicalName(classDecl.element.type)] =
          source.entryPointImport;
      if (!imports.contains(source.entryPointImport)) {
        imports.add(source.entryPointImport);
      }
  
      for (ElementAnnotation ann in classDecl.element.metadata) {
        if (ann.element is ConstructorElement) {
          ConstructorElement con = ann.element;
          if (classAnnotations
              .contains(getQualifiedName(con.enclosingElement.type))) {
            typeFactoryTypes.add(classDecl.element);
          }
        }
      }
  
      return super.visitCompilationUnitMember(classDecl);
    }
  }
  
  
negative.code:   }
  
    typeFactoryTypes.forEach((ClassElement clazz) {
      factories.write(
          'typeFactories[${resolveClassIdentifier(clazz.type)}] = (f) => ');
      factories.write('new ${resolveClassIdentifier(clazz.type)}(');
      ConstructorElement constr =
          clazz.constructors.firstWhere((c) => c.name.isEmpty);
  