Support for modular mixin resolution.

pkg/kernel/lib/analyzer/loader.dart

 // Copyright (c) 2016, 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 kernel.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 88 matching lines @@
       <ast.Library, Map<String, ast.Class>>{};
   final AnalysisContext context;
   LibraryElement _dartCoreLibrary;
   final List errors = [];
   final List libraryElements = [];
 
   /// Classes that have been referenced, and must be promoted to type level
   /// so as not to expose partially initialized classes.
   final List<ast.Class> temporaryClassWorklist = [];
 
+  final Map<LibraryElement, List<ClassElement>> mixinLibraryWorklist = {};
+
   final bool ignoreRedirectingFactories;
 
   LibraryElement _libraryBeingLoaded = null;
 
   bool get strongMode => context.analysisOptions.strongMode;
 
   DartLoader(this.repository, DartOptions options, Packages packages,
-      {DartSdk dartSdk, AnalysisContext context,
-       this.ignoreRedirectingFactories: true})
+      {DartSdk dartSdk,
+      AnalysisContext context,
+      this.ignoreRedirectingFactories: true})
       : this.context =
             context ?? createContext(options, packages, dartSdk: dartSdk),
         this.applicationRoot = options.applicationRoot;
 
   String getLibraryName(LibraryElement element) {
     return element.name.isEmpty ? null : element.name;
   }
 
   ast.Library getLibraryReference(LibraryElement element) {
     var uri = applicationRoot.relativeUri(element.source.uri);
@@ skipping 64 matching lines @@
           loadField(declaration);
         } else if (declaration is FunctionTypeAlias) {
           // Nothing to do. Typedefs are handled lazily while constructing type
           // references.
         } else {
           throw "unexpected node: ${declaration.runtimeType} $declaration";
         }
       }
     }
     libraryElements.add(element);
-    _iterateWorklist();
+    _iterateTemporaryClassWorklist();
     // Ensure everything is stored in the original declaration order.
     library.classes
       ..clear()
       ..addAll(classes)
       ..addAll(_mixinApplications[library]?.values ?? const []);
     library.fields
       ..clear()
       ..addAll(fields);
     library.procedures
       ..clear()
@@ skipping 168 matching lines @@
         if (!method.isStatic && !method.isSynthetic) {
           getMemberReference(method);
         }
       }
     }
     for (var supertype in classNode.supers) {
       promoteToHierarchyLevel(supertype.classNode);
     }
   }
 
+  void promoteToMixinLevel(ast.Class classNode, ClassElement element,
+      NamedCompilationUnitMember astNode) {
+    if (classNode.level.index >= ast.ClassLevel.Mixin.index) return;
+    promoteToHierarchyLevel(classNode);
+    classNode.level = ast.ClassLevel.Mixin;
+    // Clear out the member references that were put in the class.
+    // The AST builder will load them all put back in the right order.
+    classNode..fields.clear()..procedures.clear()..constructors.clear();
+    new ClassBodyBuilder(this, classNode, element).build(astNode);
+
+    // Ensure mixed-in classes are available.
+    for (var mixin in element.mixins) {
+      _ensureMixinBecomesLoaded(mixin.element);
+    }
+  }
+
+  /// Ensures that [element] eventually becomes loaded at least at mixin level.
+  void _ensureMixinBecomesLoaded(ClassElement element) {
+    if (isLibraryBeingLoaded(element.library)) {
+      return;
+    }
+    var class_ = getClassReference(element);
+    if (class_.level.index >= ast.ClassLevel.Mixin.index) {
+      return;
+    }
+    var list = mixinLibraryWorklist[element.library] ??= <ClassElement>[];
+    list.add(element);
+  }
+
   void promoteToBodyLevel(ast.Class classNode, ClassElement element,
       NamedCompilationUnitMember astNode) {
     if (classNode.level == ast.ClassLevel.Body) return;
-    promoteToHierarchyLevel(classNode);
+    promoteToMixinLevel(classNode, element, astNode);
     classNode.level = ast.ClassLevel.Body;
-    // Clear out the member references that were put in the class.
-    // The AST builder will load them all put back in the right order.
-    classNode..fields.clear()..procedures.clear()..constructors.clear();
-    new ClassBodyBuilder(this, classNode, element).build(astNode);
+    // This frontend delivers the same contents for classes at body and mixin
+    // levels, even though as specified, the mixin level does not require all
+    // the static members to be present.  So no additional work is needed.
   }
 
   ast.TypeParameter tryGetClassTypeParameter(TypeParameterElement element) {
     return _classTypeParameters[element];
   }
 
   Element getMemberElement(ast.Member node) {
     return _members.inverse[node];
   }
 
@@ skipping 200 matching lines @@
 
   String formatErrorMessage(
       AnalysisError error, String filename, LineInfo lines) {
     var location = lines.getLocation(error.offset);
     return '[error] ${error.message} ($filename, '
         'line ${location.lineNumber}, '
         'col ${location.columnNumber})';
   }
 
   void ensureLibraryIsLoaded(ast.Library node) {
+    _ensureLibraryIsLoaded(node);
+    _iterateMixinLibraryWorklist();
+  }
+
+  void _ensureLibraryIsLoaded(ast.Library node) {
     if (!node.isExternal) return;
     node.isExternal = false;
     var source = context.sourceFactory
         .forUri2(applicationRoot.absoluteUri(node.importUri));
     assert(source != null);
     var element = context.computeLibraryElement(source);
     var units = <CompilationUnit>[];
     bool reportErrors = node.importUri.scheme != 'dart';
     var tree = context.resolveCompilationUnit(source, element);
     units.add(tree);
@@ skipping 12 matching lines @@
       if (error.errorCode is CompileTimeErrorCode ||
           error.errorCode is ParserErrorCode ||
           error.errorCode is ScannerErrorCode ||
           error.errorCode is StrongModeCode) {
         lines ??= context.computeLineInfo(source);
         errors.add(formatErrorMessage(error, source.shortName, lines));
       }
     }
   }
 
+  void loadSdkInterface(ast.Program program, Target target) {
+    var requiredSdkMembers = target.requiredSdkClasses;
+    for (var libraryUri in requiredSdkMembers.keys) {
+      var source = context.sourceFactory.forUri2(Uri.parse(libraryUri));
+      var libraryElement = context.computeLibraryElement(source);
+      for (var member in requiredSdkMembers[libraryUri]) {
+        var type = libraryElement.getType(member);
+        if (type == null) {
+          throw 'Could not find $member in $libraryUri';
+        }
+        promoteToTypeLevel(getClassReference(type));
+      }
+    }
+    _iterateTemporaryClassWorklist();
+    _iterateMixinLibraryWorklist();
+  }
+
   void loadEverything({Target target, bool compileSdk}) {
     compileSdk ??= true;
     if (compileSdk) {
       ensureLibraryIsLoaded(getLibraryReference(getDartCoreLibrary()));
       if (target != null) {
         for (var uri in target.extraRequiredLibraries) {
           var library = _findLibraryElement(uri);
           if (library == null) {
             errors.add('Could not find required library $uri');
             continue;
@@ skipping 19 matching lines @@
       LibraryElement element = context.computeLibraryElement(context
           .sourceFactory
           .forUri2(applicationRoot.absoluteUri(library.importUri)));
       for (var unit in element.units) {
         list.add(unit.source.fullName);
       }
     }
     return list;
   }
 
-  void _iterateWorklist() {
+  void _iterateTemporaryClassWorklist() {
     while (temporaryClassWorklist.isNotEmpty) {
       var element = temporaryClassWorklist.removeLast();
       promoteToTypeLevel(element);
     }
   }
 
+  void _iterateMixinLibraryWorklist() {
+    // The worklist groups classes in the same library together so that we
+    // request resolved ASTs for each library only once.
+    while (mixinLibraryWorklist.isNotEmpty) {
+      LibraryElement library = mixinLibraryWorklist.keys.first;
+      _libraryBeingLoaded = library;
+      List<ClassElement> classes = mixinLibraryWorklist.remove(library);
+      for (var class_ in classes) {
+        var classNode = getClassReference(class_);
+        promoteToMixinLevel(classNode, class_, class_.computeNode());
+      }
+      _libraryBeingLoaded = null;
+    }
+    _iterateTemporaryClassWorklist();
+  }
+
   ast.Procedure _getMainMethod(Uri uri) {
     Source source = context.sourceFactory.forUri2(uri);
     LibraryElement library = context.computeLibraryElement(source);
     var mainElement = library.entryPoint;
     if (mainElement == null) return null;
     var mainMember = getMemberReference(mainElement);
     if (mainMember is ast.Procedure && !mainMember.isAccessor) {
       return mainMember;
     }
     // Top-level 'main' getters are not supported at the moment.
     return null;
   }
 
   ast.Procedure _makeMissingMainMethod(ast.Library library) {
     var main = new ast.Procedure(
         new ast.Name('main'),
         ast.ProcedureKind.Method,
         new ast.FunctionNode(new ast.ExpressionStatement(new ast.Throw(
             new ast.StringLiteral('Program has no main method')))),
-        isStatic: true)
-      ..fileUri = library.fileUri;
+        isStatic: true)..fileUri = library.fileUri;
     library.addMember(main);
     return main;
   }
 
   ast.Program loadProgram(Uri mainLibrary, {Target target, bool compileSdk}) {
     Uri uri = applicationRoot.relativeUri(mainLibrary);
     ast.Library library = repository.getLibraryReference(uri);
     ensureLibraryIsLoaded(library);
     var mainMethod = _getMainMethod(mainLibrary);
     loadEverything(target: target, compileSdk: compileSdk);
@@ skipping 175 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }