Fix #28120, strong mode allows field overrides

pkg/dev_compiler/lib/src/compiler/element_helpers.dart

Index: pkg/dev_compiler/lib/src/compiler/element_helpers.dart
diff --git a/pkg/dev_compiler/lib/src/compiler/element_helpers.dart b/pkg/dev_compiler/lib/src/compiler/element_helpers.dart
index 39a2e471e5182e36e642613d0ec6d3224e6c63fd..28da6a6e61ea9058e9a14959bdb0640bf18d8e4c 100644
--- a/pkg/dev_compiler/lib/src/compiler/element_helpers.dart
+++ b/pkg/dev_compiler/lib/src/compiler/element_helpers.dart
@@ -16,7 +16,12 @@ import 'package:analyzer/dart/ast/ast.dart'
         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;
@@ -139,3 +144,34 @@ List<ClassElement> getSuperclasses(ClassElement 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';