Fix two issues with modular compilation in dartk.

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 93 matching lines @@
 
   /// 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;
+  ClassElement _classBeingPromotedToMixin = null;
 
   bool get strongMode => context.analysisOptions.strongMode;
 
   DartLoader(this.repository, DartOptions options, Packages packages,
       {DartSdk dartSdk,
       AnalysisContext context,
       this.ignoreRedirectingFactories: true})
       : this.context =
             context ?? createContext(options, packages, dartSdk: dartSdk),
         this.applicationRoot = options.applicationRoot;
@@ skipping 17 matching lines @@
 
   /// True if [element] is in the process of being loaded by
   /// [_buildLibraryBody].
   ///
   /// If this is the case, we should avoid adding new members to the classes
   /// in the library, since the AST builder will rebuild the member lists.
   bool isLibraryBeingLoaded(LibraryElement element) {
     return _libraryBeingLoaded == element;
   }
 
+  bool isClassBeingPromotedToMixin(ClassElement element) {
+    return _classBeingPromotedToMixin == element;
+  }
+
   void _buildLibraryBody(LibraryElement element, ast.Library library,
       List<CompilationUnit> units) {
     assert(_libraryBeingLoaded == null);
     _libraryBeingLoaded = element;
     var classes = <ast.Class>[];
     var procedures = <ast.Procedure>[];
     var fields = <ast.Field>[];
 
     void loadClass(NamedCompilationUnitMember declaration) {
       // [declaration] can be a ClassDeclaration, EnumDeclaration, or a
@@ skipping 226 matching lines @@
       }
     }
     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;
+    _classBeingPromotedToMixin = element;
     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);
+    _classBeingPromotedToMixin = null;
 
     // 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)) {
+    if (isClassBeingPromotedToMixin(element)) {
       return;
     }
     var class_ = getClassReference(element);
     if (class_.level.index >= ast.ClassLevel.Mixin.index) {
       return;
     }
     var list = mixinLibraryWorklist[element.library] ??= <ClassElement>[];
     list.add(element);
   }
 
@@ skipping 24 matching lines @@
   ast.Member _buildMemberReference(Element element) {
     assert(element != null);
     var node = _buildOrphanedMemberReference(element);
     // Set the parent pointer and store it in the enclosing class or library.
     // If the enclosing library is being built from the AST, do not add the
     // member, since the AST builder will put it in there.
     var parent = element.enclosingElement;
     if (parent is ClassElement) {
       var class_ = getClassReference(parent);
       node.parent = class_;
-      if (!isLibraryBeingLoaded(element.library)) {
+      if (!isClassBeingPromotedToMixin(parent)) {
         class_.addMember(node);
       }
     } else {
       var library = getLibraryReference(element.library);
       node.parent = library;
       if (!isLibraryBeingLoaded(element.library)) {
         library.addMember(node);
       }
     }
     return node;
@@ skipping 504 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;
 }