Fix #28120, strong mode allows field overrides

pkg/dev_compiler/lib/src/compiler/element_helpers.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.
 
 import 'dart:collection';
 
 /// Helpers for Analyzer's Element model and corelib model.
 
 import 'package:analyzer/dart/ast/ast.dart'
     show
         ConstructorDeclaration,
         Expression,
         FunctionBody,
         FunctionExpression,
         MethodDeclaration,
         MethodInvocation,
         SimpleIdentifier;
 import 'package:analyzer/dart/element/element.dart'
-    show ClassElement, Element, ExecutableElement, FunctionElement;
+    show
+        ClassElement,
+        Element,
+        ExecutableElement,
+        FunctionElement,
+        LibraryElement;
 import 'package:analyzer/dart/element/type.dart'
     show DartType, InterfaceType, ParameterizedType;
 import 'package:analyzer/src/dart/element/type.dart' show DynamicTypeImpl;
 import 'package:analyzer/src/generated/constant.dart'
     show DartObject, DartObjectImpl;
 
 class Tuple2<T0, T1> {
   final T0 e0;
   final T1 e1;
   Tuple2(this.e0, this.e1);
@@ skipping 102 matching lines @@
       if (mixin != null) result.add(mixin);
     }
     var supertype = cls.supertype;
     if (supertype == null) break;
 
     cls = supertype.element;
     result.add(cls);
   }
   return result;
 }
+
+List<ClassElement> getSuperclassesInSameLibrary(ClassElement cls) {
+  var result = <ClassElement>[];
+  var visited = new HashSet<ClassElement>();
+  var library = cls.library;
+  while (cls != null && visited.add(cls)) {
+    for (var mixinType in cls.mixins.reversed) {

[vsm, 2017/03/27 22:31:27]

I think we should get nested mixins (see
https://codereview.chromium.org/2778083002/).

[Jennifer Messerly, 2017/03/27 23:16:27]

hmmm. Those guys unfortunately break assumptions all over the known universe,
including in Analyzer where I took this pattern from ... see
ClassElementImpl.allSupertypes and many other places. =\

I'm not sure there's any way to figure out that pattern without inspecting the
syntax? Since we're simply trying to be defensive here we could visit them. I'll
see what I can do :)

+      var mixin = mixinType.element;
+      if (mixin != null && mixin.library == library) result.add(mixin);
+    }
+    var superclass = cls.supertype?.element;
+    if (superclass?.library != library) break;

[vsm, 2017/03/27 22:31:27]

Don't we need to keep going in case we've got something like:

foo.A extends bar.B extends foo.C

?

Or, at least, until we're out of the build unit (library cycle).

[Jennifer Messerly, 2017/03/27 23:16:28]

Let me investigate based on the use cases. I only care about public types that
extend private ones in the same library, thus making them extensible. It
shouldn't matter if we cross library boundaries -- once that happens, we're in
an open world situation. If we're ever analyzing outside of a library something
broken about how the analysis works.

Build units should have nothing to do with this ... it's strictly determining
what set of fields cannot be overridden outside of their immediate library.

+
+    result.add(superclass);
+    cls = superclass;
+  }
+  return result;
+}
+
+List<ClassElement> getImmediateSuperclasses(ClassElement c) {
+  var result = <ClassElement>[];
+  for (var m in c.mixins.reversed) {
+    result.add(m.element);
+  }
+  var s = c.supertype;
+  if (s != null) result.add(s.element);
+  return result;
+}
+
+bool isSdkInternalRuntime(LibraryElement l) =>
+    l.isInSdk && l.source.uri.toString() == 'dart:_runtime';