diff --git a/pkg/analysis_server/lib/src/analysis_server.dart b/pkg/analysis_server/lib/src/analysis_server.dart
index 1ed2a48..7f6e898 100644
--- a/pkg/analysis_server/lib/src/analysis_server.dart
+++ b/pkg/analysis_server/lib/src/analysis_server.dart
@@ -1864,14 +1864,18 @@
       NotificationManager notificationManager =
           analysisServer.notificationManager;
       String path = result.path;
-      if (notificationManager != null) {
-        notificationManager.recordAnalysisErrors(
-            NotificationManager.serverId,
-            path,
-            server.doAnalysisError_listFromEngine(
-                result.driver.analysisOptions, result.lineInfo, result.errors));
-      } else {
-        new_sendErrorNotification(analysisServer, result);
+      if (analysisServer.shouldSendErrorsNotificationFor(path)) {
+        if (notificationManager != null) {
+          notificationManager.recordAnalysisErrors(
+              NotificationManager.serverId,
+              path,
+              server.doAnalysisError_listFromEngine(
+                  result.driver.analysisOptions,
+                  result.lineInfo,
+                  result.errors));
+        } else {
+          new_sendErrorNotification(analysisServer, result);
+        }
       }
       CompilationUnit unit = result.unit;
       if (unit != null) {
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index 0a364cf..398fa65 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -5831,8 +5831,9 @@
     ..add(_typeParameters)
     ..add(equals)
     ..add(_functionType);
+
   @override
-  Element get element => null;
+  Element get element => name.staticElement;
 
   @override
   GenericFunctionType get functionType => _functionType;
@@ -5855,7 +5856,6 @@
     return visitor.visitGenericTypeAlias(this);
   }
 
-  // TODO: implement element
   @override
   void visitChildren(AstVisitor visitor) {
     super.visitChildren(visitor);
@@ -9239,6 +9239,9 @@
    */
   TypeAnnotation _type;
 
+  @override
+  ParameterElement element;
+
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
@@ -9276,7 +9279,7 @@
       super._childEntities..add(keyword)..add(_type)..add(identifier);
 
   @override
-  Token get endToken => identifier.endToken;
+  Token get endToken => identifier?.endToken ?? type?.endToken;
 
   @override
   bool get isConst => keyword?.keyword == Keyword.CONST;
diff --git a/pkg/analyzer/lib/src/dart/ast/utilities.dart b/pkg/analyzer/lib/src/dart/ast/utilities.dart
index 920e585..8090044 100644
--- a/pkg/analyzer/lib/src/dart/ast/utilities.dart
+++ b/pkg/analyzer/lib/src/dart/ast/utilities.dart
@@ -6428,12 +6428,16 @@
   @override
   bool visitSimpleFormalParameter(SimpleFormalParameter node) {
     SimpleFormalParameter toNode = this._toNode as SimpleFormalParameter;
-    return _and(
+    if (_and(
         _isEqualNodes(node.documentationComment, toNode.documentationComment),
         _isEqualNodeLists(node.metadata, toNode.metadata),
         _isEqualTokens(node.keyword, toNode.keyword),
         _isEqualNodes(node.type, toNode.type),
-        _isEqualNodes(node.identifier, toNode.identifier));
+        _isEqualNodes(node.identifier, toNode.identifier))) {
+      (toNode as SimpleFormalParameterImpl).element = node.element;
+      return true;
+    }
+    return false;
   }
 
   @override
diff --git a/pkg/analyzer/lib/src/dart/element/builder.dart b/pkg/analyzer/lib/src/dart/element/builder.dart
index 3524404..cea4664 100644
--- a/pkg/analyzer/lib/src/dart/element/builder.dart
+++ b/pkg/analyzer/lib/src/dart/element/builder.dart
@@ -13,6 +13,7 @@
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ -1405,6 +1406,9 @@
       parameter.hasImplicitType = true;
     }
     _currentHolder.addParameter(parameter);
+    if (normalParameter is SimpleFormalParameterImpl) {
+      normalParameter.element = parameter;
+    }
     parameterName.staticElement = parameter;
     normalParameter.accept(this);
     return null;
@@ -1441,10 +1445,10 @@
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+    ParameterElementImpl parameter;
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
-      ParameterElementImpl parameter =
-          new ParameterElementImpl.forNode(parameterName);
+      parameter = new ParameterElementImpl.forNode(parameterName);
       _setCodeRange(parameter, node);
       parameter.isConst = node.isConst;
       parameter.isExplicitlyCovariant = node.covariantKeyword != null;
@@ -1455,11 +1459,12 @@
         parameter.hasImplicitType = true;
       }
       _currentHolder.addParameter(parameter);
-      parameterName.staticElement = parameter;
+      (node as SimpleFormalParameterImpl).element = parameter;
+      parameterName?.staticElement = parameter;
     }
     super.visitSimpleFormalParameter(node);
-    (node.element as ElementImpl).metadata =
-        _createElementAnnotations(node.metadata);
+    parameter ??= node.element;
+    parameter?.metadata = _createElementAnnotations(node.metadata);
     return null;
   }
 
diff --git a/pkg/analyzer/lib/src/generated/declaration_resolver.dart b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
index f87f5f6..333fdef 100644
--- a/pkg/analyzer/lib/src/generated/declaration_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/declaration_resolver.dart
@@ -9,6 +9,7 @@
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/builder.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ -122,8 +123,12 @@
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+    NormalFormalParameter normalParameter = node.parameter;
     ParameterElement element =
-        _match(node.parameter.identifier, _walker.getParameter());
+        _match(normalParameter.identifier, _walker.getParameter());
+    if (normalParameter is SimpleFormalParameterImpl) {
+      normalParameter.element = node.identifier.staticElement;
+    }
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       _walk(
@@ -133,7 +138,7 @@
       });
     }
     _walk(new ElementWalker.forParameter(element), () {
-      node.parameter.accept(this);
+      normalParameter.accept(this);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
@@ -365,6 +370,8 @@
     if (node.parent is! DefaultFormalParameter) {
       ParameterElement element =
           _match(node.identifier, _walker.getParameter());
+      (node as SimpleFormalParameterImpl).element =
+          node.identifier.staticElement;
       _walk(new ElementWalker.forParameter(element), () {
         super.visitSimpleFormalParameter(node);
       });
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 291f075..95c01cb 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -10076,7 +10076,7 @@
     } else {
       declaredType = _typeNameResolver._getType(typeName);
     }
-    Element element = node.identifier.staticElement;
+    Element element = node.element;
     if (element is ParameterElementImpl) {
       element.declaredType = declaredType;
     } else {
diff --git a/pkg/analyzer/test/generated/resolver_test.dart b/pkg/analyzer/test/generated/resolver_test.dart
index 8d21db67..5ce754c 100644
--- a/pkg/analyzer/test/generated/resolver_test.dart
+++ b/pkg/analyzer/test/generated/resolver_test.dart
@@ -15,6 +15,7 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/builder.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ -3202,9 +3203,9 @@
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = AstTestFactory.typeName4("int");
     String innerParameterName = "a";
-    SimpleFormalParameter parameter =
+    SimpleFormalParameterImpl parameter =
         AstTestFactory.simpleFormalParameter3(innerParameterName);
-    parameter.identifier.staticElement =
+    parameter.element = parameter.identifier.staticElement =
         ElementFactory.requiredParameter(innerParameterName);
     String outerParameterName = "p";
     FormalParameter node = AstTestFactory.fieldFormalParameter(
@@ -3415,8 +3416,8 @@
 
   test_visitSimpleFormalParameter_noType() async {
     // p
-    FormalParameter node = AstTestFactory.simpleFormalParameter3("p");
-    node.identifier.staticElement =
+    SimpleFormalParameterImpl node = AstTestFactory.simpleFormalParameter3("p");
+    node.element = node.identifier.staticElement =
         new ParameterElementImpl.forNode(AstTestFactory.identifier3("p"));
     expect(_resolveFormalParameter(node), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
@@ -3426,11 +3427,11 @@
     // int p
     InterfaceType intType = _typeProvider.intType;
     ClassElement intElement = intType.element;
-    FormalParameter node = AstTestFactory.simpleFormalParameter4(
+    SimpleFormalParameterImpl node = AstTestFactory.simpleFormalParameter4(
         AstTestFactory.typeName(intElement), "p");
     SimpleIdentifier identifier = node.identifier;
     ParameterElementImpl element = new ParameterElementImpl.forNode(identifier);
-    identifier.staticElement = element;
+    node.element = identifier.staticElement = element;
     expect(_resolveFormalParameter(node, [intElement]), same(intType));
     _listener.assertNoErrors();
   }
diff --git a/pkg/analyzer/test/src/summary/element_text.dart b/pkg/analyzer/test/src/summary/element_text.dart
new file mode 100644
index 0000000..f995195
--- /dev/null
+++ b/pkg/analyzer/test/src/summary/element_text.dart
@@ -0,0 +1,749 @@
+// Copyright (c) 2017, 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:io';
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:test/test.dart';
+
+/**
+ * Set this path to automatically replace expectations in invocations of
+ * [checkElementText] with the new actual texts.
+ */
+const String _testPath = null;
+
+/**
+ * The list of replacements that update expectations.
+ */
+final List<_Replacement> _replacements = [];
+
+/**
+ * The cached content of the file with the [_testPath].
+ */
+String _testCode;
+
+/**
+ * The cache line information for the [_testPath] file.
+ */
+LineInfo _testCodeLines;
+
+void applyCheckElementTextReplacements() {
+  if (_testPath != null && _replacements.isNotEmpty) {
+    _replacements.sort((a, b) => b.offset - a.offset);
+    String newCode = _testCode;
+    _replacements.forEach((r) {
+      newCode =
+          newCode.substring(0, r.offset) + r.text + newCode.substring(r.end);
+    });
+    new File(_testPath).writeAsStringSync(newCode);
+  }
+}
+
+/**
+ * Write the given [library] elements into the canonical text presentation
+ * taking into account the specified 'withX' options. Then compare the
+ * actual text with the given [expected] one.
+ */
+void checkElementText(LibraryElement library, String expected,
+    {bool withOffsets: false}) {
+  var writer = new _ElementWriter(withOffsets: withOffsets);
+  writer.writeLibraryElement(library);
+  String actualText = writer.buffer.toString();
+  if (_testPath != null && actualText != expected) {
+    if (_testCode == null) {
+      _testCode = new File(_testPath).readAsStringSync();
+      _testCodeLines = new LineInfo.fromContent(_testCode);
+    }
+
+    try {
+      throw 42;
+    } catch (e, trace) {
+      String traceString = trace.toString();
+
+      // Assuming traceString contains "$_testPath:$invocationLine:$column",
+      // figure out the value of invocationLine.
+
+      int testFilePathOffset = traceString.indexOf(_testPath);
+      expect(testFilePathOffset, isNonNegative);
+
+      // Sanity check: there must be ':' after the path.
+      expect(traceString[testFilePathOffset + _testPath.length], ':');
+
+      int lineOffset = testFilePathOffset + _testPath.length + ':'.length;
+      int invocationLine = int.parse(traceString.substring(
+          lineOffset, traceString.indexOf(':', lineOffset)));
+      int invocationOffset = _testCodeLines.getOffsetOfLine(invocationLine - 1);
+
+      const String rawStringPrefix = "r'''";
+      int expectationOffset =
+          _testCode.indexOf(rawStringPrefix, invocationOffset);
+
+      // Sanity check: there must be no other strings or blocks.
+      expect(_testCode.substring(invocationOffset, expectationOffset),
+          isNot(anyOf(contains("'"), contains('"'), contains('}'))));
+
+      expectationOffset += rawStringPrefix.length;
+      int expectationEnd = _testCode.indexOf("'''", expectationOffset);
+
+      _replacements.add(new _Replacement(
+          expectationOffset, expectationEnd, '\n' + actualText));
+    }
+  }
+
+  // Print the actual text to simplify copy/paste into the expectation.
+  if (actualText != expected) {
+    print('-------- Actual --------');
+    print(actualText + '------------------------');
+  }
+
+  expect(actualText, expected);
+}
+
+/**
+ * Writes the canonical text presentation of elements.
+ */
+class _ElementWriter {
+  final bool withOffsets;
+  final StringBuffer buffer = new StringBuffer();
+
+  _ElementWriter({this.withOffsets: false});
+
+  bool isDynamicType(DartType type) => type is DynamicTypeImpl;
+
+  bool isEnumElement(Element e) {
+    return e is ClassElement && e.isEnum;
+  }
+
+  void newLineIfNotEmpty() {
+    if (buffer.isNotEmpty) {
+      buffer.writeln();
+    }
+  }
+
+  void writeBodyModifiers(ExecutableElement e) {
+    if (e.isAsynchronous) {
+      expect(e.isSynchronous, isFalse);
+      buffer.write(' async');
+    }
+
+    if (e.isSynchronous && e.isGenerator) {
+      expect(e.isAsynchronous, isFalse);
+      buffer.write(' sync');
+    }
+
+    writeIf(e.isGenerator, '*');
+  }
+
+  void writeClassElement(ClassElement e) {
+    writeDocumentation(e);
+    writeMetadata(e, '', '\n');
+
+    writeIf(e.isAbstract, 'abstract ');
+
+    if (e.isEnum) {
+      buffer.write('enum ');
+    } else {
+      buffer.write('class ');
+    }
+
+    writeIf(e.isMixinApplication, 'alias ');
+
+    writeName(e);
+    writeTypeParameterElements(e.typeParameters);
+
+    if (e.supertype != null && e.supertype.displayName != 'Object' ||
+        e.mixins.isNotEmpty) {
+      buffer.write(' extends ');
+      writeType(e.supertype);
+    }
+
+    writeList(' with ', '', e.mixins, ', ', writeType);
+    writeList(' implements ', '', e.interfaces, ', ', writeType);
+
+    buffer.writeln(' {');
+
+    e.fields.forEach(writeFieldElement);
+    e.accessors.forEach(writePropertyAccessorElement);
+
+    if (e.isEnum) {
+      expect(e.constructors, isEmpty);
+    } else {
+      expect(e.constructors, isNotEmpty);
+    }
+
+    if (e.constructors.length == 1 &&
+        e.constructors[0].isSynthetic &&
+        e.mixins.isEmpty) {
+      expect(e.constructors[0].parameters, isEmpty);
+    } else {
+      e.constructors.forEach(writeConstructorElement);
+    }
+
+    e.methods.forEach(writeMethodElement);
+    buffer.writeln('}');
+  }
+
+  void writeConstructorElement(ConstructorElement e) {
+    writeDocumentation(e, '  ');
+    writeMetadata(e, '  ', '\n');
+
+    buffer.write('  ');
+
+    writeIf(e.isSynthetic, 'synthetic ');
+    writeIf(e.isExternal, 'external ');
+    writeIf(e.isConst, 'const ');
+    writeIf(e.isFactory, 'factory ');
+
+    buffer.write(e.enclosingElement.name);
+    if (e.name.isNotEmpty) {
+      buffer.write('.');
+      writeName(e);
+    }
+
+    writeParameterElements(e.parameters);
+
+    {
+      ConstructorElement redirected = e.redirectedConstructor;
+      if (redirected != null) {
+        buffer.write(' = ');
+        buffer.write(redirected.returnType);
+        if (redirected.name.isNotEmpty) {
+          buffer.write('.');
+          buffer.write(redirected.name);
+        }
+      }
+    }
+
+    if (e is ConstructorElementImpl) {
+      if (e.constantInitializers != null) {
+        writeList(' : ', '', e.constantInitializers, ', ', writeExpression);
+      }
+    }
+
+    expect(e.isAsynchronous, isFalse);
+    expect(e.isGenerator, isFalse);
+
+    buffer.writeln(';');
+  }
+
+  void writeDocumentation(Element e, [String prefix = '']) {
+    if (e.documentationComment != null) {
+      buffer.write(prefix);
+      buffer.writeln(e.documentationComment);
+    }
+  }
+
+  void writeExportElement(ExportElement e) {
+    writeMetadata(e, '', '\n');
+    buffer.write('export ');
+    writeUri(e, e.exportedLibrary.source);
+
+    e.combinators.forEach(writeNamespaceCombinator);
+
+    buffer.writeln(';');
+  }
+
+  void writeExpression(AstNode e) {
+    if (e is Annotation) {
+      buffer.write('@');
+      writeExpression(e.name);
+      if (e.constructorName != null) {
+        buffer.write('.');
+        writeExpression(e.constructorName);
+      }
+      if (e.arguments != null) {
+        writeList('(', ')', e.arguments.arguments, ', ', writeExpression,
+            includeEmpty: true);
+      }
+    } else if (e is AssertInitializer) {
+      buffer.write('assert(');
+      writeExpression(e.condition);
+      if (e.message != null) {
+        buffer.write(', ');
+        writeExpression(e.message);
+      }
+      buffer.write(')');
+    } else if (e is BinaryExpression) {
+      writeExpression(e.leftOperand);
+      buffer.write(' ');
+      buffer.write(e.operator.lexeme);
+      buffer.write(' ');
+      writeExpression(e.rightOperand);
+    } else if (e is BooleanLiteral) {
+      buffer.write(e.value);
+    } else if (e is ConditionalExpression) {
+      writeExpression(e.condition);
+      buffer.write(' ? ');
+      writeExpression(e.thenExpression);
+      buffer.write(' : ');
+      writeExpression(e.elseExpression);
+    } else if (e is ConstructorFieldInitializer) {
+      writeExpression(e.fieldName);
+      buffer.write(' = ');
+      writeExpression(e.expression);
+    } else if (e is ConstructorName) {
+      writeExpression(e.type);
+      if (e.name != null) {
+        buffer.write('.');
+        writeExpression(e.name);
+      }
+    } else if (e is DoubleLiteral) {
+      buffer.write(e.value);
+    } else if (e is InstanceCreationExpression) {
+      buffer.write(e.keyword.lexeme);
+      buffer.write(' ');
+      writeExpression(e.constructorName);
+      writeList('(', ')', e.argumentList.arguments, ', ', writeExpression,
+          includeEmpty: true);
+    } else if (e is IntegerLiteral) {
+      buffer.write(e.value);
+    } else if (e is InterpolationExpression) {
+      buffer.write(r'${');
+      writeExpression(e.expression);
+      buffer.write(r'}');
+    } else if (e is InterpolationString) {
+      buffer.write(e.value.replaceAll("'", r"\'"));
+    } else if (e is ListLiteral) {
+      if (e.constKeyword != null) {
+        buffer.write('const ');
+      }
+      if (e.typeArguments != null) {
+        writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
+      }
+      writeList('[', ']', e.elements, ', ', writeExpression,
+          includeEmpty: true);
+    } else if (e is Label) {
+      writeExpression(e.label);
+      buffer.write(': ');
+    } else if (e is MapLiteral) {
+      if (e.constKeyword != null) {
+        buffer.write('const ');
+      }
+      if (e.typeArguments != null) {
+        writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
+      }
+      writeList('{', '}', e.entries, ', ', writeExpression, includeEmpty: true);
+    } else if (e is MapLiteralEntry) {
+      writeExpression(e.key);
+      buffer.write(': ');
+      writeExpression(e.value);
+    } else if (e is NamedExpression) {
+      writeExpression(e.name);
+      buffer.write(e.expression);
+    } else if (e is NullLiteral) {
+      buffer.write('null');
+    } else if (e is PrefixExpression) {
+      buffer.write(e.operator.lexeme);
+      writeExpression(e.operand);
+    } else if (e is PrefixedIdentifier) {
+      writeExpression(e.prefix);
+      buffer.write('.');
+      writeExpression(e.identifier);
+    } else if (e is PropertyAccess) {
+      writeExpression(e.target);
+      buffer.write('.');
+      writeExpression(e.propertyName);
+    } else if (e is RedirectingConstructorInvocation) {
+      buffer.write('this');
+      if (e.constructorName != null) {
+        buffer.write('.');
+        writeExpression(e.constructorName);
+      }
+      writeList('(', ')', e.argumentList.arguments, ', ', writeExpression,
+          includeEmpty: true);
+    } else if (e is SimpleIdentifier) {
+      buffer.write(e.name);
+    } else if (e is SimpleStringLiteral) {
+      buffer.write("'");
+      buffer.write(e.value.replaceAll("'", r"\'"));
+      buffer.write("'");
+    } else if (e is StringInterpolation) {
+      buffer.write("'");
+      e.elements.forEach(writeExpression);
+      buffer.write("'");
+    } else if (e is SuperConstructorInvocation) {
+      buffer.write('super');
+      if (e.constructorName != null) {
+        buffer.write('.');
+        writeExpression(e.constructorName);
+      }
+      writeList('(', ')', e.argumentList.arguments, ', ', writeExpression,
+          includeEmpty: true);
+    } else if (e is SuperExpression) {
+      buffer.write('super');
+    } else if (e is SymbolLiteral) {
+      buffer.write('#');
+      writeList('', '', e.components, '.',
+          (Token token) => buffer.write(token.lexeme));
+    } else if (e is ThisExpression) {
+      buffer.write('this');
+    } else if (e is TypeName) {
+      writeExpression(e.name);
+      if (e.typeArguments != null) {
+        writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
+      }
+    } else {
+      fail('Unsupported expression type: ${e.runtimeType}');
+    }
+  }
+
+  void writeFieldElement(FieldElement e) {
+    if (e.isSynthetic && !isEnumElement(e.enclosingElement)) {
+      return;
+    }
+
+    writeDocumentation(e, '  ');
+    writeMetadata(e, '  ', '\n');
+
+    buffer.write('  ');
+
+    writeIf(e.isStatic, 'static ');
+    writeIf(e is FieldElementImpl && e.isCovariant, 'covariant ');
+
+    writePropertyInducingElement(e);
+  }
+
+  void writeFunctionElement(FunctionElement e) {
+    writeIf(e.isExternal, 'external ');
+
+    writeType2(e.returnType);
+
+    writeName(e);
+
+    writeTypeParameterElements(e.typeParameters);
+    writeParameterElements(e.parameters);
+
+    writeBodyModifiers(e);
+
+    buffer.writeln(' {}');
+  }
+
+  void writeFunctionTypeAliasElement(FunctionTypeAliasElement e) {
+    writeDocumentation(e);
+    writeMetadata(e, '', '\n');
+
+    buffer.write('typedef ');
+    writeType2(e.returnType);
+
+    writeName(e);
+
+    writeTypeParameterElements(e.typeParameters);
+    writeParameterElements(e.parameters);
+
+    buffer.writeln(';');
+  }
+
+  void writeIf(bool flag, String str) {
+    if (flag) {
+      buffer.write(str);
+    }
+  }
+
+  void writeImportElement(ImportElement e) {
+    if (!e.isSynthetic) {
+      writeMetadata(e, '', '\n');
+      buffer.write('import ');
+      writeUri(e, e.importedLibrary.source);
+
+      writeIf(e.isDeferred, ' deferred');
+
+      if (e.prefix != null) {
+        buffer.write(' as ');
+        writeName(e.prefix);
+        if (withOffsets) {
+          buffer.write('(${e.prefixOffset})');
+        }
+      }
+
+      e.combinators.forEach(writeNamespaceCombinator);
+
+      buffer.writeln(';');
+    }
+  }
+
+  void writeLibraryElement(LibraryElement e) {
+    if (e.displayName != '') {
+      writeMetadata(e, '', '\n');
+      buffer.write('library ');
+      writeName(e);
+      buffer.writeln(';');
+    }
+
+    e.imports.forEach(writeImportElement);
+    e.exports.forEach(writeExportElement);
+    e.parts.forEach(writePartElement);
+
+    e.units.forEach(writeUnitElement);
+  }
+
+  void writeList<T>(String open, String close, List<T> items, String separator,
+      writeItem(T item),
+      {bool includeEmpty: false}) {
+    if (!includeEmpty && items.isEmpty) {
+      return;
+    }
+    buffer.write(open);
+    bool first = true;
+    for (T item in items) {
+      if (!first) {
+        buffer.write(separator);
+      }
+      writeItem(item);
+      first = false;
+    }
+    buffer.write(close);
+  }
+
+  void writeMetadata(Element e, String prefix, String separator) {
+    if (e.metadata.isNotEmpty) {
+      writeList(prefix, '', e.metadata, '$separator$prefix', (a) {
+        writeExpression((a as ElementAnnotationImpl).annotationAst);
+      });
+      buffer.write(separator);
+    }
+  }
+
+  void writeMethodElement(MethodElement e) {
+    writeDocumentation(e, '  ');
+    writeMetadata(e, '  ', '\n');
+
+    buffer.write('  ');
+
+    writeIf(e.isExternal, 'external ');
+    writeIf(e.isStatic, 'static ');
+
+    writeType2(e.returnType);
+
+    writeName(e);
+
+    writeTypeParameterElements(e.typeParameters);
+    writeParameterElements(e.parameters);
+
+    writeBodyModifiers(e);
+
+    if (e.isAbstract) {
+      buffer.writeln(';');
+    } else {
+      buffer.writeln(' {}');
+    }
+  }
+
+  void writeName(Element e) {
+    buffer.write(e.displayName);
+    if (withOffsets) {
+      buffer.write('@');
+      buffer.write(e.nameOffset);
+    }
+  }
+
+  void writeNamespaceCombinator(NamespaceCombinator e) {
+    if (e is ShowElementCombinator) {
+      buffer.write(' show ');
+      buffer.write(e.shownNames.join(', '));
+    } else if (e is HideElementCombinator) {
+      buffer.write(' hide ');
+      buffer.write(e.hiddenNames.join(', '));
+    }
+  }
+
+  void writeParameterElement(ParameterElement e) {
+    String defaultValueSeparator;
+    Expression defaultValue =
+        e is DefaultParameterElementImpl ? e.constantInitializer : null;
+    String closeString;
+    ParameterKind kind = e.parameterKind;
+    if (kind == ParameterKind.REQUIRED) {
+      closeString = '';
+    } else if (kind == ParameterKind.POSITIONAL) {
+      buffer.write('[');
+      defaultValueSeparator = ' = ';
+      closeString = ']';
+    } else if (kind == ParameterKind.NAMED) {
+      buffer.write('{');
+      defaultValueSeparator = ': ';
+      closeString = '}';
+    } else {
+      fail('Unknown parameter kind: $kind');
+    }
+
+    writeMetadata(e, '', ' ');
+
+    writeIf(e.isCovariant, 'covariant ');
+    writeIf(e.isFinal, 'final ');
+
+    writeType2(e.type);
+
+    if (e is FieldFormalParameterElement) {
+      buffer.write('this.');
+    }
+
+    writeName(e);
+
+    if (defaultValue != null) {
+      buffer.write(defaultValueSeparator);
+      writeExpression(defaultValue);
+    }
+
+    buffer.write(closeString);
+  }
+
+  void writeParameterElements(List<ParameterElement> elements) {
+    writeList('(', ')', elements, ', ', writeParameterElement,
+        includeEmpty: true);
+  }
+
+  void writePartElement(CompilationUnitElement e) {
+    writeMetadata(e, '', '\n');
+    buffer.write('part ');
+    writeUri(e, e.source);
+    buffer.writeln(';');
+  }
+
+  void writePropertyAccessorElement(PropertyAccessorElement e) {
+    if (e.isSynthetic) {
+      return;
+    }
+
+    if (e.enclosingElement is ClassElement) {
+      writeDocumentation(e, '  ');
+      writeMetadata(e, '  ', '\n');
+
+      buffer.write('  ');
+
+      writeIf(e.isStatic, 'static ');
+    } else {
+      writeDocumentation(e);
+      writeMetadata(e, '', '\n');
+    }
+
+    writeIf(e.isExternal, 'external ');
+
+    writeType2(e.returnType);
+
+    if (e.isGetter) {
+      buffer.write('get ');
+    } else {
+      buffer.write('set ');
+    }
+
+    writeName(e);
+
+    if (e.isSetter || e.parameters.isNotEmpty) {
+      writeParameterElements(e.parameters);
+    }
+
+    expect(e.typeParameters, isEmpty);
+
+    expect(e.isSynchronous, isTrue);
+    expect(e.isAsynchronous, isFalse);
+    expect(e.isGenerator, isFalse);
+
+    if (e.isAbstract) {
+      buffer.writeln(';');
+    } else {
+      buffer.writeln(' {}');
+    }
+  }
+
+  void writePropertyInducingElement(PropertyInducingElement e) {
+    DartType type = e.type;
+    expect(type, isNotNull);
+
+    writeIf(e.isFinal, 'final ');
+    writeIf(e.isConst, 'const ');
+    writeType2(type);
+
+    writeName(e);
+
+    if (e is ConstVariableElement) {
+      Expression initializer = (e as ConstVariableElement).constantInitializer;
+      if (initializer != null) {
+        buffer.write(' = ');
+        writeExpression(initializer);
+      }
+    }
+
+    // TODO(scheglov) Paul: One of the things that was hardest to get right
+    // when resynthesizing the element model was the synthetic function for the
+    // initializer.  Can we write that out (along with its return type)?
+
+    buffer.writeln(';');
+  }
+
+  void writeTopLevelVariableElement(TopLevelVariableElement e) {
+    if (e.isSynthetic) {
+      return;
+    }
+    writeDocumentation(e);
+    writeMetadata(e, '', '\n');
+    writePropertyInducingElement(e);
+  }
+
+  void writeType(DartType type) {
+    if (type is InterfaceType) {
+      buffer.write(type.element.name);
+      if (type.element.typeParameters.isNotEmpty) {
+        writeList('<', '>', type.typeArguments, ', ', writeType);
+      }
+    } else {
+      buffer.write(type.displayName);
+    }
+  }
+
+  void writeType2(DartType type) {
+    writeType(type);
+    buffer.write(' ');
+  }
+
+  void writeTypeParameterElement(TypeParameterElement e) {
+    writeName(e);
+    if (e.bound != null) {
+      buffer.write(' extends ');
+      writeType(e.bound);
+    }
+  }
+
+  void writeTypeParameterElements(List<TypeParameterElement> elements) {
+    writeList('<', '>', elements, ', ', writeTypeParameterElement);
+  }
+
+  void writeUnitElement(CompilationUnitElement e) {
+    if (e.library.definingCompilationUnit != e) {
+      buffer.writeln('-' * 20);
+      buffer.writeln('unit: ${e.source.shortName}');
+      buffer.writeln();
+    }
+    e.functionTypeAliases.forEach(writeFunctionTypeAliasElement);
+    e.enums.forEach(writeClassElement);
+    e.types.forEach(writeClassElement);
+    e.topLevelVariables.forEach(writeTopLevelVariableElement);
+    e.accessors.forEach(writePropertyAccessorElement);
+    e.functions.forEach(writeFunctionElement);
+  }
+
+  void writeUri(UriReferencedElement e, Source source) {
+    String uri = e.uri ?? source.uri.toString();
+    buffer.write('\'$uri\'');
+    if (withOffsets) {
+      buffer.write('(');
+      buffer.write('${e.uriOffset}, ');
+      buffer.write('${e.uriEnd})');
+      buffer.write(')');
+    }
+  }
+}
+
+class _Replacement {
+  final int offset;
+  final int end;
+  final String text;
+  _Replacement(this.offset, this.end, this.text);
+}
diff --git a/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart b/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart
index 5efc290..139a553 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_ast_test.dart
@@ -29,6 +29,7 @@
 
 import '../context/abstract_context.dart';
 import '../task/strong/inferred_type_test.dart';
+import 'element_text.dart';
 import 'resynthesize_common.dart';
 import 'summary_common.dart';
 
@@ -37,13 +38,24 @@
     defineReflectiveTests(ResynthesizeAstSpecTest);
     defineReflectiveTests(ResynthesizeAstStrongTest);
     defineReflectiveTests(AstInferredTypeTest);
+    defineReflectiveTests(ApplyCheckElementTextReplacements);
   });
 }
 
 @reflectiveTest
+class ApplyCheckElementTextReplacements {
+  test_applyReplacements() {
+    applyCheckElementTextReplacements();
+  }
+}
+
+@reflectiveTest
 class AstInferredTypeTest extends AbstractResynthesizeTest
     with _AstResynthesizeTestMixin, InferredTypeMixin {
   @override
+  bool get isStrongMode => true;
+
+  @override
   bool get mayCheckTypesOfLocals => false;
 
   @override
@@ -686,13 +698,15 @@
 @reflectiveTest
 class ResynthesizeAstSpecTest extends _ResynthesizeAstTest {
   @override
-  AnalysisOptionsImpl createOptions() =>
-      super.createOptions()..strongMode = false;
+  bool get isStrongMode => false;
 }
 
 @reflectiveTest
 class ResynthesizeAstStrongTest extends _ResynthesizeAstTest {
   @override
+  bool get isStrongMode => true;
+
+  @override
   AnalysisOptionsImpl createOptions() =>
       super.createOptions()..strongMode = true;
 
@@ -880,6 +894,8 @@
 
 abstract class _ResynthesizeAstTest extends ResynthesizeTest
     with _AstResynthesizeTestMixin {
+  bool get isStrongMode;
+
   @override
   LibraryElementImpl checkLibrary(String text,
       {bool allowErrors: false, bool dumpSummaries: false}) {
@@ -907,6 +923,10 @@
   DartSdk createDartSdk() => AbstractContextTest.SHARED_MOCK_SDK;
 
   @override
+  AnalysisOptionsImpl createOptions() =>
+      super.createOptions()..strongMode = isStrongMode;
+
+  @override
   TestSummaryResynthesizer encodeDecodeLibrarySource(Source source) {
     return _encodeLibrary(source);
   }
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 51b77ed..c1d72d5 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -29,9 +29,12 @@
 import '../../generated/test_support.dart';
 import '../abstract_single_unit.dart';
 import '../context/abstract_context.dart';
+import 'element_text.dart';
 
 /**
  * Abstract base class for resynthesizing and comparing elements.
+ *
+ * The return type separator: →
  */
 abstract class AbstractResynthesizeTest extends AbstractSingleUnitTest {
   Set<Source> otherLibrarySources = new Set<Source>();
@@ -53,6 +56,11 @@
    */
   bool allowMissingFiles = false;
 
+  /**
+   * Return `true` if resynthesizing should be done is strong mode.
+   */
+  bool get isStrongMode;
+
   void addLibrary(String uri) {
     otherLibrarySources.add(context.sourceFactory.forUri(uri));
   }
@@ -1317,23 +1325,105 @@
   SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource);
 
   fail_library_hasExtUri() {
-    checkLibrary('import "dart-ext:doesNotExist.dart";');
+    var library = checkLibrary('import "dart-ext:doesNotExist.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+''');
+    }
   }
 
   test_class_abstract() {
-    checkLibrary('abstract class C {}');
+    var library = checkLibrary('abstract class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+}
+''');
+    }
   }
 
   test_class_alias() {
-    checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
+    var library =
+        checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class alias C extends D with E, F {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+class F {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class alias C extends D with E, F {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+class F {
+}
+''');
+    }
   }
 
   test_class_alias_abstract() {
-    checkLibrary('abstract class C = D with E; class D {} class E {}');
+    var library =
+        checkLibrary('abstract class C = D with E; class D {} class E {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+abstract class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+abstract class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+    }
   }
 
   test_class_alias_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
@@ -1342,6 +1432,37 @@
 
 class D {}
 class E {}''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+''');
+    }
   }
 
   test_class_alias_with_forwarding_constructors() {
@@ -1359,35 +1480,122 @@
   factory Base.fact2() = Base.noArgs;
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import "a.dart";
 class M {}
 class MixinApp = Base with M;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class M {
+}
+class alias MixinApp extends Base with M {
+  synthetic MixinApp._priv() = Base._priv;
+  synthetic MixinApp() = Base;
+  synthetic MixinApp.noArgs() = Base.noArgs;
+  synthetic MixinApp.requiredArg(dynamic x) = Base.requiredArg;
+  synthetic MixinApp.fact() = Base.fact;
+  synthetic MixinApp.fact2() = Base.fact2;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class M {
+}
+class alias MixinApp extends Base with M {
+  synthetic MixinApp._priv() = Base._priv;
+  synthetic MixinApp() = Base;
+  synthetic MixinApp.noArgs() = Base.noArgs;
+  synthetic MixinApp.requiredArg(dynamic x) = Base.requiredArg;
+  synthetic MixinApp.fact() = Base.fact;
+  synthetic MixinApp.fact2() = Base.fact2;
+}
+''');
+    }
   }
 
   test_class_alias_with_forwarding_constructors_type_substitution() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class Base<T> {
   Base.ctor(T t, List<T> l);
 }
 class M {}
 class MixinApp = Base with M;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class Base<T> {
+  Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp extends Base<dynamic> with M {
+  synthetic MixinApp.ctor(dynamic t, List<dynamic> l) = Base<T>.ctor;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class Base<T> {
+  Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp extends Base<dynamic> with M {
+  synthetic MixinApp.ctor(dynamic t, List<dynamic> l) = Base<T>.ctor;
+}
+''');
+    }
   }
 
   test_class_alias_with_forwarding_constructors_type_substitution_complex() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class Base<T> {
   Base.ctor(T t, List<T> l);
 }
 class M {}
 class MixinApp<U> = Base<List<U>> with M;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class Base<T> {
+  Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp<U> extends Base<List<U>> with M {
+  synthetic MixinApp.ctor(List<U> t, List<List<U>> l) = Base<T>.ctor;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class Base<T> {
+  Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class alias MixinApp<U> extends Base<List<U>> with M {
+  synthetic MixinApp.ctor(List<U> t, List<List<U>> l) = Base<T>.ctor;
+}
+''');
+    }
   }
 
   test_class_alias_with_mixin_members() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C = D with E;
 class D {}
 class E {
@@ -1396,133 +1604,680 @@
   void f() {}
   int x;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+  int x;
+  int get a {}
+  void set b(int i) {}
+  void f() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+  int x;
+  int get a {}
+  void set b(int i) {}
+  void f() {}
+}
+''');
+    }
   }
 
   test_class_constructor_const() {
-    checkLibrary('class C { const C(); }');
+    var library = checkLibrary('class C { const C(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C();
+}
+''');
+    }
   }
 
   test_class_constructor_const_external() {
-    checkLibrary('class C { external const C(); }');
+    var library = checkLibrary('class C { external const C(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external const C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external const C();
+}
+''');
+    }
   }
 
   test_class_constructor_explicit_named() {
-    checkLibrary('class C { C.foo(); }');
+    var library = checkLibrary('class C { C.foo(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.foo();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.foo();
+}
+''');
+    }
   }
 
   test_class_constructor_explicit_type_params() {
-    checkLibrary('class C<T, U> { C(); }');
+    var library = checkLibrary('class C<T, U> { C(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  C();
+}
+''');
+    }
   }
 
   test_class_constructor_explicit_unnamed() {
-    checkLibrary('class C { C(); }');
+    var library = checkLibrary('class C { C(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    }
   }
 
   test_class_constructor_external() {
-    checkLibrary('class C { external C(); }');
+    var library = checkLibrary('class C { external C(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external C();
+}
+''');
+    }
   }
 
   test_class_constructor_factory() {
-    checkLibrary('class C { factory C() => null; }');
+    var library = checkLibrary('class C { factory C() => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  factory C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  factory C();
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_dynamic_dynamic() {
-    checkLibrary('class C { dynamic x; C(dynamic this.x); }');
+    var library = checkLibrary('class C { dynamic x; C(dynamic this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_dynamic_typed() {
-    checkLibrary('class C { dynamic x; C(int this.x); }');
+    var library = checkLibrary('class C { dynamic x; C(int this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(int this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(int this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_dynamic_untyped() {
-    checkLibrary('class C { dynamic x; C(this.x); }');
+    var library = checkLibrary('class C { dynamic x; C(this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_multiple_matching_fields() {
     // This is a compile-time error but it should still analyze consistently.
-    checkLibrary('class C { C(this.x); int x; String x; }', allowErrors: true);
+    var library = checkLibrary('class C { C(this.x); int x; String x; }',
+        allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  String x;
+  C(int this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  String x;
+  C(int this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_no_matching_field() {
     // This is a compile-time error but it should still analyze consistently.
-    checkLibrary('class C { C(this.x); }', allowErrors: true);
+    var library = checkLibrary('class C { C(this.x); }', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C(dynamic this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C(dynamic this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_typed_dynamic() {
-    checkLibrary('class C { num x; C(dynamic this.x); }', allowErrors: true);
+    var library = checkLibrary('class C { num x; C(dynamic this.x); }',
+        allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num x;
+  C(dynamic this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num x;
+  C(dynamic this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_typed_typed() {
-    checkLibrary('class C { num x; C(int this.x); }');
+    var library = checkLibrary('class C { num x; C(int this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num x;
+  C(int this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num x;
+  C(int this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_typed_untyped() {
-    checkLibrary('class C { num x; C(this.x); }');
+    var library = checkLibrary('class C { num x; C(this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num x;
+  C(num this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num x;
+  C(num this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_untyped_dynamic() {
-    checkLibrary('class C { var x; C(dynamic this.x); }');
+    var library = checkLibrary('class C { var x; C(dynamic this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_untyped_typed() {
-    checkLibrary('class C { var x; C(int this.x); }');
+    var library = checkLibrary('class C { var x; C(int this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(int this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(int this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_field_formal_untyped_untyped() {
-    checkLibrary('class C { var x; C(this.x); }');
+    var library = checkLibrary('class C { var x; C(this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(dynamic this.x);
+}
+''');
+    }
   }
 
   test_class_constructor_fieldFormal_named_noDefault() {
-    checkLibrary('class C { int x; C({this.x}); }');
+    var library = checkLibrary('class C { int x; C({this.x}); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C({int this.x});
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C({int this.x});
+}
+''');
+    }
   }
 
   test_class_constructor_fieldFormal_named_withDefault() {
-    checkLibrary('class C { int x; C({this.x: 42}); }');
+    var library = checkLibrary('class C { int x; C({this.x: 42}); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C({int this.x});
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C({int this.x});
+}
+''');
+    }
   }
 
   test_class_constructor_fieldFormal_optional_noDefault() {
-    checkLibrary('class C { int x; C([this.x]); }');
+    var library = checkLibrary('class C { int x; C([this.x]); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C([int this.x]);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C([int this.x]);
+}
+''');
+    }
   }
 
   test_class_constructor_fieldFormal_optional_withDefault() {
-    checkLibrary('class C { int x; C([this.x = 42]); }');
+    var library = checkLibrary('class C { int x; C([this.x = 42]); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C([int this.x]);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+  C([int this.x]);
+}
+''');
+    }
   }
 
   test_class_constructor_implicit() {
-    checkLibrary('class C {}');
+    var library = checkLibrary('class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+''');
+    }
   }
 
   test_class_constructor_implicit_type_params() {
-    checkLibrary('class C<T, U> {}');
+    var library = checkLibrary('class C<T, U> {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+''');
+    }
   }
 
   test_class_constructor_params() {
-    checkLibrary('class C { C(x, y); }');
+    var library = checkLibrary('class C { C(x, int y); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C(dynamic x, int y);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C(dynamic x, int y);
+}
+''');
+    }
   }
 
   test_class_constructors() {
-    checkLibrary('class C { C.foo(); C.bar(); }');
+    var library = checkLibrary('class C { C.foo(); C.bar(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.foo();
+  C.bar();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.foo();
+  C.bar();
+}
+''');
+    }
   }
 
   test_class_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 class C {}''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+    }
   }
 
   test_class_documented_tripleSlash() {
-    checkLibrary('''
+    var library = checkLibrary('''
 /// aaa
 /// bbbb
 /// cc
 class C {}''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/// aaa
+/// bbbb
+/// cc
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/// aaa
+/// bbbb
+/// cc
+class C {
+}
+''');
+    }
   }
 
   test_class_documented_with_references() {
-    checkLibrary('''
+    var library = checkLibrary('''
 /**
  * Docs referring to [D] and [E]
  */
@@ -1530,174 +2285,897 @@
 
 class D {}
 class E {}''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs referring to [D] and [E]
+ */
+class C {
+}
+class D {
+}
+class E {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs referring to [D] and [E]
+ */
+class C {
+}
+class D {
+}
+class E {
+}
+''');
+    }
   }
 
   test_class_documented_with_windows_line_endings() {
-    checkLibrary('/**\r\n * Docs\r\n */\r\nclass C {}');
+    var library = checkLibrary('/**\r\n * Docs\r\n */\r\nclass C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+class C {
+}
+''');
+    }
   }
 
   test_class_field_const() {
-    checkLibrary('class C { static const int i = 0; }');
+    var library = checkLibrary('class C { static const int i = 0; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const int i = 0;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const int i = 0;
+}
+''');
+    }
   }
 
   test_class_field_implicit_type() {
-    checkLibrary('class C { var x; }');
+    var library = checkLibrary('class C { var x; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+}
+''');
+    }
   }
 
   test_class_field_static() {
-    checkLibrary('class C { static int i; }');
+    var library = checkLibrary('class C { static int i; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int i;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int i;
+}
+''');
+    }
   }
 
   test_class_fields() {
-    checkLibrary('class C { int i; int j; }');
+    var library = checkLibrary('class C { int i; int j; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int i;
+  int j;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int i;
+  int j;
+}
+''');
+    }
   }
 
   test_class_getter_abstract() {
-    checkLibrary('abstract class C { int get x; }');
+    var library = checkLibrary('abstract class C { int get x; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+  int get x;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+  int get x;
+}
+''');
+    }
   }
 
   test_class_getter_external() {
-    checkLibrary('class C { external int get x; }');
+    var library = checkLibrary('class C { external int get x; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external int get x {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external int get x {}
+}
+''');
+    }
   }
 
   test_class_getter_implicit_return_type() {
-    checkLibrary('class C { get x => null; }');
+    var library = checkLibrary('class C { get x => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic get x {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic get x {}
+}
+''');
+    }
   }
 
   test_class_getter_static() {
-    checkLibrary('class C { static int get x => null; }');
+    var library = checkLibrary('class C { static int get x => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int get x {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int get x {}
+}
+''');
+    }
   }
 
   test_class_getters() {
-    checkLibrary('class C { int get x => null; get y => null; }');
+    var library = checkLibrary('class C { int get x => null; get y => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int get x {}
+  dynamic get y {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int get x {}
+  dynamic get y {}
+}
+''');
+    }
   }
 
   test_class_implicitField_getterFirst() {
-    checkLibrary('class C { int get x => 0; void set x(int value) {} }');
+    var library =
+        checkLibrary('class C { int get x => 0; void set x(int value) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int get x {}
+  void set x(int value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int get x {}
+  void set x(int value) {}
+}
+''');
+    }
   }
 
   test_class_implicitField_setterFirst() {
-    checkLibrary('class C { void set x(int value) {} int get x => 0; }');
+    var library =
+        checkLibrary('class C { void set x(int value) {} int get x => 0; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(int value) {}
+  int get x {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(int value) {}
+  int get x {}
+}
+''');
+    }
   }
 
   test_class_interfaces() {
-    checkLibrary('class C implements D, E {} class D {} class E {}');
+    var library =
+        checkLibrary('class C implements D, E {} class D {} class E {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C implements D, E {
+}
+class D {
+}
+class E {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C implements D, E {
+}
+class D {
+}
+class E {
+}
+''');
+    }
   }
 
   test_class_interfaces_unresolved() {
-    checkLibrary('class C implements X, Y, Z {} class X {} class Z {}',
+    var library = checkLibrary(
+        'class C implements X, Y, Z {} class X {} class Z {}',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C implements X, Z {
+}
+class X {
+}
+class Z {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C implements X, Z {
+}
+class X {
+}
+class Z {
+}
+''');
+    }
   }
 
   test_class_method_abstract() {
-    checkLibrary('abstract class C { f(); }');
+    var library = checkLibrary('abstract class C { f(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+  dynamic f();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+  dynamic f();
+}
+''');
+    }
   }
 
   test_class_method_external() {
-    checkLibrary('class C { external f(); }');
+    var library = checkLibrary('class C { external f(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external dynamic f() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external dynamic f() {}
+}
+''');
+    }
   }
 
   test_class_method_params() {
-    checkLibrary('class C { f(x, y) {} }');
+    var library = checkLibrary('class C { f(x, y) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f(dynamic x, dynamic y) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f(dynamic x, dynamic y) {}
+}
+''');
+    }
   }
 
   test_class_method_static() {
-    checkLibrary('class C { static f() {} }');
+    var library = checkLibrary('class C { static f() {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static dynamic f() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static dynamic f() {}
+}
+''');
+    }
   }
 
   test_class_methods() {
-    checkLibrary('class C { f() {} g() {} }');
+    var library = checkLibrary('class C { f() {} g() {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f() {}
+  dynamic g() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f() {}
+  dynamic g() {}
+}
+''');
+    }
   }
 
   test_class_mixins() {
-    checkLibrary('class C extends Object with D, E {} class D {} class E {}');
+    var library = checkLibrary(
+        'class C extends Object with D, E {} class D {} class E {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends Object with D, E {
+  synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends Object with D, E {
+  synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+    }
   }
 
   test_class_mixins_unresolved() {
-    checkLibrary('class C extends Object with X, Y, Z; class X {} class Z {}',
+    var library = checkLibrary(
+        'class C extends Object with X, Y, Z; class X {} class Z {}',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends Object with X, Z {
+  synthetic C();
+}
+class X {
+}
+class Z {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends Object with X, Z {
+  synthetic C();
+}
+class X {
+}
+class Z {
+}
+''');
+    }
   }
 
   test_class_setter_abstract() {
-    checkLibrary('abstract class C { void set x(int value); }');
+    var library = checkLibrary('abstract class C { void set x(int value); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+  void set x(int value);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+abstract class C {
+  void set x(int value);
+}
+''');
+    }
   }
 
   test_class_setter_external() {
-    checkLibrary('class C { external void set x(int value); }');
+    var library = checkLibrary('class C { external void set x(int value); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external void set x(int value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external void set x(int value) {}
+}
+''');
+    }
   }
 
   test_class_setter_implicit_param_type() {
-    checkLibrary('class C { void set x(value) {} }');
+    var library = checkLibrary('class C { void set x(value) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(dynamic value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(dynamic value) {}
+}
+''');
+    }
   }
 
   test_class_setter_implicit_return_type() {
-    checkLibrary('class C { set x(int value) {} }');
+    var library = checkLibrary('class C { set x(int value) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(int value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic set x(int value) {}
+}
+''');
+    }
   }
 
   test_class_setter_invalid_no_parameter() {
-    checkLibrary('class C { void set x() {} }');
+    var library = checkLibrary('class C { void set x() {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x() {}
+}
+''');
+    }
   }
 
   test_class_setter_static() {
-    checkLibrary('class C { static void set x(int value) {} }');
+    var library = checkLibrary('class C { static void set x(int value) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static void set x(int value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static void set x(int value) {}
+}
+''');
+    }
   }
 
   test_class_setters() {
-    checkLibrary('class C { void set x(int value) {} set y(value) {} }');
+    var library =
+        checkLibrary('class C { void set x(int value) {} set y(value) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(int value) {}
+  void set y(dynamic value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(int value) {}
+  dynamic set y(dynamic value) {}
+}
+''');
+    }
   }
 
   test_class_supertype() {
-    checkLibrary('class C extends D {} class D {}');
+    var library = checkLibrary('class C extends D {} class D {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+}
+class D {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+}
+class D {
+}
+''');
+    }
   }
 
   test_class_supertype_unresolved() {
-    checkLibrary('class C extends D {}', allowErrors: true);
+    var library = checkLibrary('class C extends D {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+''');
+    }
   }
 
   test_class_type_parameters() {
-    checkLibrary('class C<T, U> {}');
+    var library = checkLibrary('class C<T, U> {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+''');
+    }
   }
 
   test_class_type_parameters_bound() {
-    checkLibrary('class C<T extends Object, U extends D> {} class D {}');
+    var library =
+        checkLibrary('class C<T extends Object, U extends D> {} class D {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T extends Object, U extends D> {
+}
+class D {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T extends Object, U extends D> {
+}
+class D {
+}
+''');
+    }
   }
 
   test_class_type_parameters_f_bound_complex() {
-    checkLibrary('class C<T extends List<U>, U> {}');
+    var library = checkLibrary('class C<T extends List<U>, U> {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T extends List<U>, U> {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T extends List<U>, U> {
+}
+''');
+    }
   }
 
   test_class_type_parameters_f_bound_simple() {
-    checkLibrary('class C<T extends U, U> {}');
+    var library = checkLibrary('class C<T extends U, U> {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T extends U, U> {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T extends U, U> {
+}
+''');
+    }
   }
 
   test_classes() {
-    checkLibrary('class C {} class D {}');
+    var library = checkLibrary('class C {} class D {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+class D {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+class D {
+}
+''');
+    }
   }
 
   test_closure_executable_with_return_type_from_closure() {
-    checkLibrary('''
+    var library = checkLibrary('''
 f() {
   print(() {});
   print(() => () => 0);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    }
   }
 
   test_closure_generic() {
-    checkLibrary('final f = <U, V>(U x, V y) => y;');
+    var library = checkLibrary('final f = <U, V>(U x, V y) => y;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+final <U,V>(U, V) → V f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+final dynamic f;
+''');
+    }
   }
 
   test_closure_in_variable_declaration_in_part() {
     addSource('/a.dart', 'part of lib; final f = (int i) => i.toDouble();');
-    checkLibrary('''
+    var library = checkLibrary('''
 library lib;
 part "a.dart";
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+final (int) → double f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+final dynamic f;
+''');
+    }
   }
 
   test_const_invalid_field_const() {
     variablesWithNotConstInitializers.add('f');
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 class C {
   static const f = 1 + foo();
@@ -1705,11 +3183,30 @@
 int foo() => 42;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const int f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const dynamic f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+    }
   }
 
   test_const_invalid_field_final() {
     variablesWithNotConstInitializers.add('f');
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 class C {
   final f = 1 + foo();
@@ -1717,25 +3214,78 @@
 int foo() => 42;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final int f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic f = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+    }
   }
 
   test_const_invalid_topLevel() {
     variablesWithNotConstInitializers.add('v');
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 const v = 1 + foo();
 int foo() => 42;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const int v = $$invalidConstExpr$$;
+int foo() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic v = $$invalidConstExpr$$;
+int foo() {}
+''');
+    }
   }
 
   test_const_invokeConstructor_generic_named() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C<K, V> {
   const C.named(K k, V v);
 }
 const V = const C<int, String>.named(1, '222');
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<K, V> {
+  const C.named(K k, V v);
+}
+const C<int, String> V = const C<int, String>.named(1, '222');
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<K, V> {
+  const C.named(K k, V v);
+}
+const dynamic V = const C<int, String>.named(1, '222');
+''');
+    }
   }
 
   test_const_invokeConstructor_generic_named_imported() {
@@ -1746,10 +3296,25 @@
   const C.named(K k, V v);
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const V = const C<int, String>.named(1, '222');
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const C<int, String> V = const C<int, String>.named(1, '222');
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic V = const C<int, String>.named(1, '222');
+''');
+    }
   }
 
   test_const_invokeConstructor_generic_named_imported_withPrefix() {
@@ -1760,28 +3325,81 @@
   const C.named(K k, V v);
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C<int, String>.named(1, '222');
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const C<int, String> V = const C<int, String>.named(1, '222');
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const C<int, String>.named(1, '222');
+''');
+    }
   }
 
   test_const_invokeConstructor_generic_noTypeArguments() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C<K, V> {
   const C();
 }
 const V = const C();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<K, V> {
+  const C();
+}
+const C<dynamic, dynamic> V = const C();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<K, V> {
+  const C();
+}
+const dynamic V = const C();
+''');
+    }
   }
 
   test_const_invokeConstructor_generic_unnamed() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C<K, V> {
   const C();
 }
 const V = const C<int, String>();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<K, V> {
+  const C();
+}
+const C<int, String> V = const C<int, String>();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<K, V> {
+  const C();
+}
+const dynamic V = const C<int, String>();
+''');
+    }
   }
 
   test_const_invokeConstructor_generic_unnamed_imported() {
@@ -1792,10 +3410,25 @@
   const C();
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const V = const C<int, String>();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const C<int, String> V = const C<int, String>();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic V = const C<int, String>();
+''');
+    }
   }
 
   test_const_invokeConstructor_generic_unnamed_imported_withPrefix() {
@@ -1806,19 +3439,53 @@
   const C();
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C<int, String>();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const C<int, String> V = const C<int, String>();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const C<int, String>();
+''');
+    }
   }
 
   test_const_invokeConstructor_named() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   const C.named(bool a, int b, int c, {String d, double e});
 }
 const V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C.named(bool a, int b, int c, {String d}, {double e});
+}
+const C V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C.named(bool a, int b, int c, {String d}, {double e});
+}
+const dynamic V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
+''');
+    }
   }
 
   test_const_invokeConstructor_named_imported() {
@@ -1829,10 +3496,25 @@
   const C.named();
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const V = const C.named();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const C V = const C.named();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic V = const C.named();
+''');
+    }
   }
 
   test_const_invokeConstructor_named_imported_withPrefix() {
@@ -1843,27 +3525,72 @@
   const C.named();
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C.named();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const C V = const C.named();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const C.named();
+''');
+    }
   }
 
   test_const_invokeConstructor_named_unresolved() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 class C {}
 const V = const C.named();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+const C V = const C.named();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+const dynamic V = const C.named();
+''');
+    }
   }
 
   test_const_invokeConstructor_named_unresolved2() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 const V = const C.named();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const C.named();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const C.named();
+''');
+    }
   }
 
   test_const_invokeConstructor_named_unresolved3() {
@@ -1873,39 +3600,101 @@
 class C {
 }
 ''');
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 import 'a.dart' as p;
 const V = const p.C.named();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const C V = const p.C.named();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const p.C.named();
+''');
+    }
   }
 
   test_const_invokeConstructor_named_unresolved4() {
     addLibrarySource('/a.dart', '');
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 import 'a.dart' as p;
 const V = const p.C.named();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const p.C.named();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const p.C.named();
+''');
+    }
   }
 
   test_const_invokeConstructor_named_unresolved5() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 const V = const p.C.named();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const p.C.named();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const p.C.named();
+''');
+    }
   }
 
   test_const_invokeConstructor_unnamed() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   const C();
 }
 const V = const C();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C();
+}
+const C V = const C();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C();
+}
+const dynamic V = const C();
+''');
+    }
   }
 
   test_const_invokeConstructor_unnamed_imported() {
@@ -1916,10 +3705,25 @@
   const C();
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const V = const C();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const C V = const C();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic V = const C();
+''');
+    }
   }
 
   test_const_invokeConstructor_unnamed_imported_withPrefix() {
@@ -1930,45 +3734,120 @@
   const C();
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const V = const p.C();
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const C V = const C();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const C();
+''');
+    }
   }
 
   test_const_invokeConstructor_unnamed_unresolved() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 const V = const C();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const C();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const C();
+''');
+    }
   }
 
   test_const_invokeConstructor_unnamed_unresolved2() {
     addLibrarySource('/a.dart', '');
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 import 'a.dart' as p;
 const V = const p.C();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const p.C();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = const p.C();
+''');
+    }
   }
 
   test_const_invokeConstructor_unnamed_unresolved3() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 const V = const p.C();
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const p.C();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = const p.C();
+''');
+    }
   }
 
   test_const_length_ofClassConstField() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   static const String F = '';
 }
 const int v = C.F.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const String F = '';
+}
+const int v = C.F.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const String F = '';
+}
+const int v = C.F.length;
+''');
+    }
   }
 
   test_const_length_ofClassConstField_imported() {
@@ -1979,10 +3858,25 @@
   static const String F = '';
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const int v = C.F.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const int v = C.F.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const int v = C.F.length;
+''');
+    }
   }
 
   test_const_length_ofClassConstField_imported_withPrefix() {
@@ -1993,23 +3887,66 @@
   static const String F = '';
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const int v = p.C.F.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const int v = p.C.F.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const int v = p.C.F.length;
+''');
+    }
   }
 
   test_const_length_ofStringLiteral() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const v = 'abc'.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const int v = 'abc'.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic v = 'abc'.length;
+''');
+    }
   }
 
   test_const_length_ofTopLevelVariable() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const String S = 'abc';
 const v = S.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const String S = 'abc';
+const int v = S.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const String S = 'abc';
+const dynamic v = S.length;
+''');
+    }
   }
 
   test_const_length_ofTopLevelVariable_imported() {
@@ -2018,10 +3955,25 @@
         r'''
 const String S = 'abc';
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const v = S.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const int v = S.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic v = S.length;
+''');
+    }
   }
 
   test_const_length_ofTopLevelVariable_imported_withPrefix() {
@@ -2030,51 +3982,144 @@
         r'''
 const String S = 'abc';
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const v = p.S.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const int v = p.S.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic v = p.S.length;
+''');
+    }
   }
 
   test_const_length_staticMethod() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   static int length() => 42;
 }
 const v = C.length;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int length() {}
+}
+const () → int v = C.length;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int length() {}
+}
+const dynamic v = C.length;
+''');
+    }
   }
 
   test_const_parameterDefaultValue_initializingFormal_functionTyped() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   final x;
   const C({this.x: foo});
 }
 int foo() => 42;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C({dynamic this.x});
+}
+int foo() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C({dynamic this.x});
+}
+int foo() {}
+''');
+    }
   }
 
   test_const_parameterDefaultValue_initializingFormal_named() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   final x;
   const C({this.x: 1 + 2});
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C({dynamic this.x});
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C({dynamic this.x});
+}
+''');
+    }
   }
 
   test_const_parameterDefaultValue_initializingFormal_positional() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   final x;
   const C([this.x = 1 + 2]);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C([dynamic this.x]);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C([dynamic this.x]);
+}
+''');
+    }
   }
 
   test_const_parameterDefaultValue_normal() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   const C.positional([p = 1 + 2]);
   const C.named({p: 1 + 2});
@@ -2084,15 +4129,61 @@
   void methodNamedWithoutDefault({p}) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C.positional([dynamic p = 1 + 2]);
+  const C.named({dynamic p: 1 + 2});
+  void methodPositional([dynamic p = 1 + 2]) {}
+  void methodPositionalWithoutDefault([dynamic p]) {}
+  void methodNamed({dynamic p: 1 + 2}) {}
+  void methodNamedWithoutDefault({dynamic p}) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C.positional([dynamic p = 1 + 2]);
+  const C.named({dynamic p: 1 + 2});
+  void methodPositional([dynamic p = 1 + 2]) {}
+  void methodPositionalWithoutDefault([dynamic p]) {}
+  void methodNamed({dynamic p: 1 + 2}) {}
+  void methodNamedWithoutDefault({dynamic p}) {}
+}
+''');
+    }
   }
 
   test_const_reference_staticField() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   static const int F = 42;
 }
 const V = C.F;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const int F = 42;
+}
+const int V = C.F;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const int F = 42;
+}
+const dynamic V = C.F;
+''');
+    }
   }
 
   test_const_reference_staticField_imported() {
@@ -2103,10 +4194,25 @@
   static const int F = 42;
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const V = C.F;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const int V = C.F;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic V = C.F;
+''');
+    }
   }
 
   test_const_reference_staticField_imported_withPrefix() {
@@ -2117,19 +4223,53 @@
   static const int F = 42;
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const V = p.C.F;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const int V = p.C.F;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = p.C.F;
+''');
+    }
   }
 
   test_const_reference_staticMethod() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   static int m(int a, String b) => 42;
 }
 const V = C.m;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int m(int a, String b) {}
+}
+const (int, String) → int V = C.m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int m(int a, String b) {}
+}
+const dynamic V = C.m;
+''');
+    }
   }
 
   test_const_reference_staticMethod_imported() {
@@ -2140,10 +4280,25 @@
   static int m(int a, String b) => 42;
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const V = C.m;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const (int, String) → int V = C.m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic V = C.m;
+''');
+    }
   }
 
   test_const_reference_staticMethod_imported_withPrefix() {
@@ -2154,17 +4309,47 @@
   static int m(int a, String b) => 42;
 }
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const V = p.C.m;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const (int, String) → int V = p.C.m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = p.C.m;
+''');
+    }
   }
 
   test_const_reference_topLevelFunction() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 foo() {}
 const V = foo;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const () → dynamic V = foo;
+dynamic foo() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = foo;
+dynamic foo() {}
+''');
+    }
   }
 
   test_const_reference_topLevelFunction_imported() {
@@ -2173,10 +4358,25 @@
         r'''
 foo() {}
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const V = foo;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const () → dynamic V = foo;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic V = foo;
+''');
+    }
   }
 
   test_const_reference_topLevelFunction_imported_withPrefix() {
@@ -2185,17 +4385,47 @@
         r'''
 foo() {}
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const V = p.foo;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const () → dynamic V = p.foo;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic V = p.foo;
+''');
+    }
   }
 
   test_const_reference_topLevelVariable() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const A = 1;
 const B = A + 2;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const int A = 1;
+const int B = A + 2;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic A = 1;
+const dynamic B = A + 2;
+''');
+    }
   }
 
   test_const_reference_topLevelVariable_imported() {
@@ -2204,10 +4434,25 @@
         r'''
 const A = 1;
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const B = A + 2;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const int B = A + 2;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic B = A + 2;
+''');
+    }
   }
 
   test_const_reference_topLevelVariable_imported_withPrefix() {
@@ -2216,14 +4461,29 @@
         r'''
 const A = 1;
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const B = p.A + 2;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const int B = p.A + 2;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic B = p.A + 2;
+''');
+    }
   }
 
   test_const_reference_type() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {}
 class D<T> {}
 enum E {a, b, c}
@@ -2236,15 +4496,83 @@
 const vEnum = E;
 const vFunctionTypeAlias = F;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(int a, String b);
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E a;
+  static const E b;
+  static const E c;
+}
+class C {
+}
+class D<T> {
+}
+const Type vDynamic = dynamic;
+const Type vNull = Null;
+const Type vObject = Object;
+const Type vClass = C;
+const Type vGenericClass = D;
+const Type vEnum = E;
+const Type vFunctionTypeAlias = F;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(int a, String b);
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E a;
+  static const E b;
+  static const E c;
+}
+class C {
+}
+class D<T> {
+}
+const dynamic vDynamic = dynamic;
+const dynamic vNull = Null;
+const dynamic vObject = Object;
+const dynamic vClass = C;
+const dynamic vGenericClass = D;
+const dynamic vEnum = E;
+const dynamic vFunctionTypeAlias = F;
+''');
+    }
   }
 
   test_const_reference_type_functionType() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 typedef F();
 class C {
   final f = <F>[];
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+class C {
+  final List<F> f = const <F>[];
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+class C {
+  final dynamic f = const <F>[];
+}
+''');
+    }
   }
 
   test_const_reference_type_imported() {
@@ -2255,12 +4583,31 @@
 enum E {a, b, c}
 typedef F(int a, String b);
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const vClass = C;
 const vEnum = E;
 const vFunctionTypeAlias = F;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const Type vClass = C;
+const Type vEnum = E;
+const Type vFunctionTypeAlias = F;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic vClass = C;
+const dynamic vEnum = E;
+const dynamic vFunctionTypeAlias = F;
+''');
+    }
   }
 
   test_const_reference_type_imported_withPrefix() {
@@ -2271,37 +4618,103 @@
 enum E {a, b, c}
 typedef F(int a, String b);
 ''');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const vClass = p.C;
 const vEnum = p.E;
 const vFunctionTypeAlias = p.F;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const Type vClass = p.C;
+const Type vEnum = p.E;
+const Type vFunctionTypeAlias = p.F;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic vClass = p.C;
+const dynamic vEnum = p.E;
+const dynamic vFunctionTypeAlias = p.F;
+''');
+    }
   }
 
   test_const_reference_type_typeParameter() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C<T> {
   final f = <T>[];
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  final List<T> f = const <T>[];
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  final dynamic f = const <T>[];
+}
+''');
+    }
   }
 
   test_const_reference_unresolved_prefix0() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 const V = foo;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = foo;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic V = foo;
+''');
+    }
   }
 
   test_const_reference_unresolved_prefix1() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 class C {}
 const v = C.foo;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+const dynamic v = C.foo;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+const dynamic v = C.foo;
+''');
+    }
   }
 
   test_const_reference_unresolved_prefix2() {
@@ -2310,16 +4723,31 @@
         '''
 class C {}
 ''');
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 import 'foo.dart' as p;
 const v = p.C.foo;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as p;
+const dynamic v = p.C.foo;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as p;
+const dynamic v = p.C.foo;
+''');
+    }
   }
 
   test_const_topLevel_binary() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vEqual = 1 == 2;
 const vAnd = true && false;
 const vOr = false || true;
@@ -2339,28 +4767,114 @@
 const vLess = 1 < 2;
 const vLessEqual = 1 <= 2;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const bool vEqual = 1 == 2;
+const bool vAnd = true && false;
+const bool vOr = false || true;
+const int vBitXor = 1 ^ 2;
+const int vBitAnd = 1 & 2;
+const int vBitOr = 1 | 2;
+const int vBitShiftLeft = 1 << 2;
+const int vBitShiftRight = 1 >> 2;
+const int vAdd = 1 + 2;
+const int vSubtract = 1 - 2;
+const int vMiltiply = 1 * 2;
+const num vDivide = 1 / 2;
+const int vFloorDivide = 1 ~/ 2;
+const int vModulo = 1 % 2;
+const bool vGreater = 1 > 2;
+const bool vGreaterEqual = 1 >= 2;
+const bool vLess = 1 < 2;
+const bool vLessEqual = 1 <= 2;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vEqual = 1 == 2;
+const dynamic vAnd = true && false;
+const dynamic vOr = false || true;
+const dynamic vBitXor = 1 ^ 2;
+const dynamic vBitAnd = 1 & 2;
+const dynamic vBitOr = 1 | 2;
+const dynamic vBitShiftLeft = 1 << 2;
+const dynamic vBitShiftRight = 1 >> 2;
+const dynamic vAdd = 1 + 2;
+const dynamic vSubtract = 1 - 2;
+const dynamic vMiltiply = 1 * 2;
+const dynamic vDivide = 1 / 2;
+const dynamic vFloorDivide = 1 ~/ 2;
+const dynamic vModulo = 1 % 2;
+const dynamic vGreater = 1 > 2;
+const dynamic vGreaterEqual = 1 >= 2;
+const dynamic vLess = 1 < 2;
+const dynamic vLessEqual = 1 <= 2;
+''');
+    }
   }
 
   test_const_topLevel_conditional() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vConditional = (1 == 2) ? 11 : 22;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const int vConditional = 1 == 2 ? 11 : 22;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vConditional = 1 == 2 ? 11 : 22;
+''');
+    }
   }
 
   test_const_topLevel_identical() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vIdentical = (1 == 2) ? 11 : 22;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const int vIdentical = 1 == 2 ? 11 : 22;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vIdentical = 1 == 2 ? 11 : 22;
+''');
+    }
   }
 
   test_const_topLevel_ifNull() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vIfNull = 1 ?? 2.0;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const num vIfNull = 1 ?? 2.0;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vIfNull = 1 ?? 2.0;
+''');
+    }
   }
 
   test_const_topLevel_literal() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vNull = null;
 const vBoolFalse = false;
 const vBoolTrue = true;
@@ -2372,31 +4886,107 @@
 const vStringInterpolation = 'aaa ${true} ${42} bbb';
 const vSymbol = #aaa.bbb.ccc;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic vNull = null;
+const bool vBoolFalse = false;
+const bool vBoolTrue = true;
+const int vInt = 1;
+const int vIntLong = 44998905507923676709665;
+const double vDouble = 2.3;
+const String vString = 'abc';
+const String vStringConcat = 'aaabbb';
+const String vStringInterpolation = 'aaa ${true} ${42} bbb';
+const Symbol vSymbol = #aaa.bbb.ccc;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vNull = null;
+const dynamic vBoolFalse = false;
+const dynamic vBoolTrue = true;
+const dynamic vInt = 1;
+const dynamic vIntLong = 44998905507923676709665;
+const dynamic vDouble = 2.3;
+const dynamic vString = 'abc';
+const dynamic vStringConcat = 'aaabbb';
+const dynamic vStringInterpolation = 'aaa ${true} ${42} bbb';
+const dynamic vSymbol = #aaa.bbb.ccc;
+''');
+    }
   }
 
   test_const_topLevel_prefix() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vNotEqual = 1 != 2;
 const vNot = !true;
 const vNegate = -1;
 const vComplement = ~1;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const bool vNotEqual = 1 != 2;
+const bool vNot = !true;
+const int vNegate = -1;
+const int vComplement = ~1;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vNotEqual = 1 != 2;
+const dynamic vNot = !true;
+const dynamic vNegate = -1;
+const dynamic vComplement = ~1;
+''');
+    }
   }
 
   test_const_topLevel_super() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vSuper = super;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic vSuper = super;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vSuper = super;
+''');
+    }
   }
 
   test_const_topLevel_this() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vThis = this;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic vThis = this;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vThis = this;
+''');
+    }
   }
 
   test_const_topLevel_typedList() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vNull = const <Null>[];
 const vDynamic = const <dynamic>[1, 2, 3];
 const vInterfaceNoTypeParameters = const <int>[1, 2, 3];
@@ -2404,101 +4994,313 @@
 const vInterfaceWithTypeArguments = const <List<String>>[];
 const vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const List<Null> vNull = const <Null>[];
+const List<dynamic> vDynamic = const <dynamic>[1, 2, 3];
+const List<int> vInterfaceNoTypeParameters = const <int>[1, 2, 3];
+const List<List<dynamic>> vInterfaceNoTypeArguments = const <List>[];
+const List<List<String>> vInterfaceWithTypeArguments = const <List<String>>[];
+const List<Map<int, List<String>>> vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vNull = const <Null>[];
+const dynamic vDynamic = const <dynamic>[1, 2, 3];
+const dynamic vInterfaceNoTypeParameters = const <int>[1, 2, 3];
+const dynamic vInterfaceNoTypeArguments = const <List>[];
+const dynamic vInterfaceWithTypeArguments = const <List<String>>[];
+const dynamic vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
+''');
+    }
   }
 
   test_const_topLevel_typedList_imported() {
     addLibrarySource('/a.dart', 'class C {}');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart';
 const v = const <C>[];
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const List<C> v = const <C>[];
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+const dynamic v = const <C>[];
+''');
+    }
   }
 
   test_const_topLevel_typedList_importedWithPrefix() {
     addLibrarySource('/a.dart', 'class C {}');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'a.dart' as p;
 const v = const <p.C>[];
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const List<C> v = const <C>[];
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as p;
+const dynamic v = const <C>[];
+''');
+    }
   }
 
   test_const_topLevel_typedMap() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const vDynamic1 = const <dynamic, int>{};
 const vDynamic2 = const <int, dynamic>{};
 const vInterface = const <int, String>{};
 const vInterfaceWithTypeArguments = const <int, List<String>>{};
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const Map<dynamic, int> vDynamic1 = const <dynamic, int>{};
+const Map<int, dynamic> vDynamic2 = const <int, dynamic>{};
+const Map<int, String> vInterface = const <int, String>{};
+const Map<int, List<String>> vInterfaceWithTypeArguments = const <int, List<String>>{};
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic vDynamic1 = const <dynamic, int>{};
+const dynamic vDynamic2 = const <int, dynamic>{};
+const dynamic vInterface = const <int, String>{};
+const dynamic vInterfaceWithTypeArguments = const <int, List<String>>{};
+''');
+    }
   }
 
   test_const_topLevel_untypedList() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const v = const [1, 2, 3];
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const List<int> v = const [1, 2, 3];
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic v = const [1, 2, 3];
+''');
+    }
   }
 
   test_const_topLevel_untypedMap() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 const v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const Map<int, String> v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
+''');
+    }
   }
 
   test_constExpr_pushReference_field_simpleIdentifier() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   static const a = b;
   static const b = null;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const dynamic a = C.b;
+  static const dynamic b = null;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const dynamic a = C.b;
+  static const dynamic b = null;
+}
+''');
+    }
   }
 
   test_constExpr_pushReference_staticMethod_simpleIdentifier() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   static const a = m;
   static m() {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const () → dynamic a = C.m;
+  static dynamic m() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const dynamic a = C.m;
+  static dynamic m() {}
+}
+''');
+    }
   }
 
   test_constructor_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   /**
    * Docs
    */
   C();
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  /**
+   * Docs
+   */
+  C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  /**
+   * Docs
+   */
+  C();
+}
+''');
+    }
   }
 
   test_constructor_initializers_assertInvocation() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   const C(int x) : assert(x >= 42);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C(int x) : assert(x >= 42);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C(int x) : assert(x >= 42);
+}
+''');
+    }
   }
 
   test_constructor_initializers_assertInvocation_message() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   const C(int x) : assert(x >= 42, 'foo');
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C(int x) : assert(x >= 42, 'foo');
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C(int x) : assert(x >= 42, 'foo');
+}
+''');
+    }
   }
 
   test_constructor_initializers_field() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   final x;
   const C() : x = 42;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C() : x = 42;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C() : x = 42;
+}
+''');
+    }
   }
 
   test_constructor_initializers_field_notConst() {
     variablesWithNotConstInitializers.add('x');
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class C {
   final x;
@@ -2507,19 +5309,59 @@
 int foo() => 42;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C() : x = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C() : x = $$invalidConstExpr$$;
+}
+int foo() {}
+''');
+    }
   }
 
   test_constructor_initializers_field_withParameter() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   final x;
   const C(int p) : x = 1 + p;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C(int p) : x = 1 + p;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C(int p) : x = 1 + p;
+}
+''');
+    }
   }
 
   test_constructor_initializers_superInvocation_named() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class A {
   const A.aaa(int p);
 }
@@ -2527,10 +5369,33 @@
   const C() : super.aaa(42);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A.aaa(int p);
+}
+class C extends A {
+  const C() : super.aaa(42);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A.aaa(int p);
+}
+class C extends A {
+  const C() : super.aaa(42);
+}
+''');
+    }
   }
 
   test_constructor_initializers_superInvocation_namedExpression() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class A {
   const A.aaa(a, {int b});
 }
@@ -2538,10 +5403,33 @@
   const C() : super.aaa(1, b: 2);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A.aaa(dynamic a, {int b});
+}
+class C extends A {
+  const C() : super.aaa(1, b: 2);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A.aaa(dynamic a, {int b});
+}
+class C extends A {
+  const C() : super.aaa(1, b: 2);
+}
+''');
+    }
   }
 
   test_constructor_initializers_superInvocation_unnamed() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class A {
   const A(int p);
 }
@@ -2549,37 +5437,117 @@
   const C.ccc() : super(42);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A(int p);
+}
+class C extends A {
+  const C.ccc() : super(42);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A(int p);
+}
+class C extends A {
+  const C.ccc() : super(42);
+}
+''');
+    }
   }
 
   test_constructor_initializers_thisInvocation_named() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   const C() : this.named(1, 'bbb');
   const C.named(int a, String b);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C() = C.named : this.named(1, 'bbb');
+  const C.named(int a, String b);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C() = C.named : this.named(1, 'bbb');
+  const C.named(int a, String b);
+}
+''');
+    }
   }
 
   test_constructor_initializers_thisInvocation_namedExpression() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   const C() : this.named(1, b: 2);
   const C.named(a, {int b});
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C() = C.named : this.named(1, b: 2);
+  const C.named(dynamic a, {int b});
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C() = C.named : this.named(1, b: 2);
+  const C.named(dynamic a, {int b});
+}
+''');
+    }
   }
 
   test_constructor_initializers_thisInvocation_unnamed() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   const C.named() : this(1, 'bbb');
   const C(int a, String b);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C.named() = C : this(1, 'bbb');
+  const C(int a, String b);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  const C.named() = C : this(1, 'bbb');
+  const C(int a, String b);
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   factory C() = D.named;
   C._();
@@ -2588,10 +5556,35 @@
   D.named() : super._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  factory C() = D.named;
+  C._();
+}
+class D extends C {
+  D.named();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  factory C() = D.named;
+  C._();
+}
+class D extends C {
+  D.named();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named_generic() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T, U> {
   factory C() = D<U, T>.named;
   C._();
@@ -2600,6 +5593,31 @@
   D.named() : super._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  factory C() = D<U, T>.named;
+  C._();
+}
+class D<T, U> extends C<U, T> {
+  D.named();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  factory C() = D<U, T>.named;
+  C._();
+}
+class D<T, U> extends C<U, T> {
+  D.named();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named_imported() {
@@ -2611,13 +5629,34 @@
   D.named() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart';
 class C {
   factory C() = D.named;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C {
+  factory C() = D.named;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C {
+  factory C() = D.named;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named_imported_generic() {
@@ -2629,13 +5668,34 @@
   D.named() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart';
 class C<T, U> {
   factory C() = D<U, T>.named;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C<T, U> {
+  factory C() = D<U, T>.named;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C<T, U> {
+  factory C() = D<U, T>.named;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named_prefixed() {
@@ -2647,13 +5707,34 @@
   D.named() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart' as foo;
 class C {
   factory C() = foo.D.named;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C {
+  factory C() = D.named;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C {
+  factory C() = D.named;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named_prefixed_generic() {
@@ -2665,27 +5746,65 @@
   D.named() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart' as foo;
 class C<T, U> {
   factory C() = foo.D<U, T>.named;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+  factory C() = D<U, T>.named;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+  factory C() = D<U, T>.named;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named_unresolved_class() {
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class C<E> {
   factory C() = D.named<E>;
 }
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<E> {
+  factory C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<E> {
+  factory C();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_named_unresolved_constructor() {
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class D {}
 class C<E> {
@@ -2693,10 +5812,31 @@
 }
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class D {
+}
+class C<E> {
+  factory C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class D {
+}
+class C<E> {
+  factory C();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_unnamed() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   factory C() = D;
   C._();
@@ -2705,10 +5845,35 @@
   D() : super._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  factory C() = D;
+  C._();
+}
+class D extends C {
+  D();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  factory C() = D;
+  C._();
+}
+class D extends C {
+  D();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_unnamed_generic() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T, U> {
   factory C() = D<U, T>;
   C._();
@@ -2717,6 +5882,31 @@
   D() : super._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  factory C() = D<U, T>;
+  C._();
+}
+class D<T, U> extends C<U, T> {
+  D();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  factory C() = D<U, T>;
+  C._();
+}
+class D<T, U> extends C<U, T> {
+  D();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_unnamed_imported() {
@@ -2728,13 +5918,34 @@
   D() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart';
 class C {
   factory C() = D;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C {
+  factory C() = D;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C {
+  factory C() = D;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_unnamed_imported_generic() {
@@ -2746,13 +5957,34 @@
   D() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart';
 class C<T, U> {
   factory C() = D<U, T>;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C<T, U> {
+  factory C() = D<U, T>;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class C<T, U> {
+  factory C() = D<U, T>;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_unnamed_prefixed() {
@@ -2764,13 +5996,34 @@
   D() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart' as foo;
 class C {
   factory C() = foo.D;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C {
+  factory C() = D;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C {
+  factory C() = D;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_unnamed_prefixed_generic() {
@@ -2782,63 +6035,177 @@
   D() : super._();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'foo.dart' as foo;
 class C<T, U> {
   factory C() = foo.D<U, T>;
   C._();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+  factory C() = D<U, T>;
+  C._();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+  factory C() = D<U, T>;
+  C._();
+}
+''');
+    }
   }
 
   test_constructor_redirected_factory_unnamed_unresolved() {
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class C<E> {
   factory C() = D<E>;
 }
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<E> {
+  factory C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<E> {
+  factory C();
+}
+''');
+    }
   }
 
   test_constructor_redirected_thisInvocation_named() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   C.named();
   C() : this.named();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.named();
+  C() = C.named;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.named();
+  C() = C.named;
+}
+''');
+    }
   }
 
   test_constructor_redirected_thisInvocation_named_generic() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T> {
   C.named();
   C() : this.named();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  C.named();
+  C() = C<T>.named;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  C.named();
+  C() = C<T>.named;
+}
+''');
+    }
   }
 
   test_constructor_redirected_thisInvocation_unnamed() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   C();
   C.named() : this();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+  C.named() = C;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+  C.named() = C;
+}
+''');
+    }
   }
 
   test_constructor_redirected_thisInvocation_unnamed_generic() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T> {
   C();
   C.named() : this();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  C();
+  C.named() = C<T>;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  C();
+  C.named() = C<T>;
+}
+''');
+    }
   }
 
   test_constructor_withCycles_const() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   final x;
   const C() : x = const D();
@@ -2848,10 +6215,37 @@
   const D() : x = const C();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C() : x = const D();
+}
+class D {
+  final dynamic x;
+  const D() : x = const C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  const C() : x = const D();
+}
+class D {
+  final dynamic x;
+  const D() : x = const C();
+}
+''');
+    }
   }
 
   test_constructor_withCycles_nonConst() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   final x;
   C() : x = new D();
@@ -2861,10 +6255,37 @@
   D() : x = new C();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  C();
+}
+class D {
+  final dynamic x;
+  D();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x;
+  C();
+}
+class D {
+  final dynamic x;
+  D();
+}
+''');
+    }
   }
 
   test_defaultValue_refersToGenericClass_constructor() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class B<T> {
   const B();
 }
@@ -2872,10 +6293,33 @@
   const C([B<T> b = const B()]);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+class C<T> {
+  const C([B<T> b = const B()]);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+class C<T> {
+  const C([B<T> b = const B()]);
+}
+''');
+    }
   }
 
   test_defaultValue_refersToGenericClass_constructor2() {
-    checkLibrary('''
+    var library = checkLibrary('''
 abstract class A<T> {}
 class B<T> implements A<T> {
   const B();
@@ -2884,19 +6328,65 @@
   const C([A<T> a = const B()]);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+abstract class A<T> {
+}
+class B<T> implements A<T> {
+  const B();
+}
+class C<T> implements A<Iterable<T>> {
+  const C([A<T> a = const B()]);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+abstract class A<T> {
+}
+class B<T> implements A<T> {
+  const B();
+}
+class C<T> implements A<Iterable<T>> {
+  const C([A<T> a = const B()]);
+}
+''');
+    }
   }
 
   test_defaultValue_refersToGenericClass_functionG() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class B<T> {
   const B();
 }
 void foo<T>([B<T> b = const B()]) {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+void foo<T>([B<T> b = const B()]) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+void foo<T>([B<T> b = const B()]) {}
+''');
+    }
   }
 
   test_defaultValue_refersToGenericClass_methodG() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class B<T> {
   const B();
 }
@@ -2904,10 +6394,33 @@
   void foo<T>([B<T> b = const B()]) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+class C {
+  void foo<T>([B<T> b = const B()]) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+class C {
+  void foo<T>([B<T> b = const B()]) {}
+}
+''');
+    }
   }
 
   test_defaultValue_refersToGenericClass_methodG_classG() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class B<T1, T2> {
   const B();
 }
@@ -2915,10 +6428,33 @@
   void foo<E2>([B<E1, E2> b = const B()]) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class B<T1, T2> {
+  const B();
+}
+class C<E1> {
+  void foo<E2>([B<E1, E2> b = const B()]) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class B<T1, T2> {
+  const B();
+}
+class C<E1> {
+  void foo<E2>([B<E1, E2> b = const B()]) {}
+}
+''');
+    }
   }
 
   test_defaultValue_refersToGenericClass_methodNG() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class B<T> {
   const B();
 }
@@ -2926,37 +6462,168 @@
   void foo([B<T> b = const B()]) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+class C<T> {
+  void foo([B<T> b = const B()]) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class B<T> {
+  const B();
+}
+class C<T> {
+  void foo([B<T> b = const B()]) {}
+}
+''');
+    }
   }
 
   test_enum_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 enum E { v }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+''');
+    }
   }
 
   test_enum_value_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 enum E {
   /**
    * Docs
    */
   v
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  /**
+   * Docs
+   */
+  static const E v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  /**
+   * Docs
+   */
+  static const E v;
+}
+''');
+    }
   }
 
   test_enum_values() {
-    checkLibrary('enum E { v1, v2 }');
+    var library = checkLibrary('enum E { v1, v2 }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v1;
+  static const E v2;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v1;
+  static const E v2;
+}
+''');
+    }
   }
 
   test_enums() {
-    checkLibrary('enum E1 { v1 } enum E2 { v2 }');
+    var library = checkLibrary('enum E1 { v1 } enum E2 { v2 }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+enum E1 {
+  final int index;
+  static const List<E1> values;
+  static const E1 v1;
+}
+enum E2 {
+  final int index;
+  static const List<E2> values;
+  static const E2 v2;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+enum E1 {
+  final int index;
+  static const List<E1> values;
+  static const E1 v1;
+}
+enum E2 {
+  final int index;
+  static const List<E2> values;
+  static const E2 v2;
+}
+''');
+    }
   }
 
   test_error_extendsEnum() {
-    checkLibrary('''
+    var library = checkLibrary('''
 enum E {a, b, c}
 
 class M {}
@@ -2975,24 +6642,120 @@
 
 class D = Object with M, E;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E a;
+  static const E b;
+  static const E c;
+}
+class M {
+}
+class A {
+  dynamic foo() {}
+}
+class B implements M {
+  dynamic foo() {}
+}
+class C extends Object with M {
+  synthetic C();
+  dynamic foo() {}
+}
+class alias D extends Object with M {
+  synthetic D() = Object;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E a;
+  static const E b;
+  static const E c;
+}
+class M {
+}
+class A {
+  dynamic foo() {}
+}
+class B implements M {
+  dynamic foo() {}
+}
+class C extends Object with M {
+  synthetic C();
+  dynamic foo() {}
+}
+class alias D extends Object with M {
+  synthetic D() = Object;
+}
+''');
+    }
   }
 
   test_executable_parameter_type_typedef() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 typedef F(int p);
 main(F f) {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(int p);
+dynamic main(F f) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(int p);
+dynamic main(F f) {}
+''');
+    }
   }
 
   test_export_class() {
     addLibrarySource('/a.dart', 'class C {}');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_class_type_alias() {
     addLibrarySource(
         '/a.dart', 'class C {} exends _D with _E; class _D {} class _E {}');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_configurations_useDefault() {
@@ -3005,6 +6768,19 @@
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'foo.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'foo.dart';
+''');
+    }
     expect(library.exports[0].uri, 'foo.dart');
     expect(library.exports[0].exportedLibrary.source.shortName, 'foo.dart');
   }
@@ -3020,6 +6796,19 @@
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'foo_io.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'foo_io.dart';
+''');
+    }
     expect(library.exports[0].uri, 'foo_io.dart');
     expect(library.exports[0].exportedLibrary.source.shortName, 'foo_io.dart');
   }
@@ -3035,6 +6824,19 @@
   if (dart.library.io) 'foo_io.dart'
   if (dart.library.html) 'foo_html.dart';
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'foo_html.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'foo_html.dart';
+''');
+    }
     ExportElement export = library.exports[0];
     expect(export.uri, 'foo_html.dart');
     expect(export.exportedLibrary.source.shortName, 'foo_html.dart');
@@ -3042,52 +6844,182 @@
 
   test_export_function() {
     addLibrarySource('/a.dart', 'f() {}');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_getter() {
     addLibrarySource('/a.dart', 'get f() => null;');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_hide() {
     addLibrary('dart:async');
-    checkLibrary('export "dart:async" hide Stream, Future;');
+    var library = checkLibrary('export "dart:async" hide Stream, Future;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'dart:async' hide Stream, Future;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'dart:async' hide Stream, Future;
+''');
+    }
   }
 
   test_export_multiple_combinators() {
     addLibrary('dart:async');
-    checkLibrary('export "dart:async" hide Stream show Future;');
+    var library = checkLibrary('export "dart:async" hide Stream show Future;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'dart:async' hide Stream show Future;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'dart:async' hide Stream show Future;
+''');
+    }
   }
 
   test_export_setter() {
     addLibrarySource('/a.dart', 'void set f(value) {}');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_show() {
     addLibrary('dart:async');
-    checkLibrary('export "dart:async" show Future, Stream;');
+    var library = checkLibrary('export "dart:async" show Future, Stream;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'dart:async' show Future, Stream;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'dart:async' show Future, Stream;
+''');
+    }
   }
 
   test_export_typedef() {
     addLibrarySource('/a.dart', 'typedef F();');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_variable() {
     addLibrarySource('/a.dart', 'var x;');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_variable_const() {
     addLibrarySource('/a.dart', 'const x = 0;');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_export_variable_final() {
     addLibrarySource('/a.dart', 'final x = 0;');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_exportImport_configurations_useDefault() {
@@ -3106,6 +7038,23 @@
 import 'bar.dart';
 class B extends A {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+    }
     var typeA = library.definingCompilationUnit.getType('B').supertype;
     expect(typeA.element.source.shortName, 'foo.dart');
   }
@@ -3127,6 +7076,23 @@
 import 'bar.dart';
 class B extends A {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+    }
     var typeA = library.definingCompilationUnit.getType('B').supertype;
     expect(typeA.element.source.shortName, 'foo_io.dart');
   }
@@ -3134,215 +7100,849 @@
   test_exports() {
     addLibrarySource('/a.dart', 'library a;');
     addLibrarySource('/b.dart', 'library b;');
-    checkLibrary('export "a.dart"; export "b.dart";');
+    var library = checkLibrary('export "a.dart"; export "b.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+export 'b.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+export 'b.dart';
+''');
+    }
   }
 
   test_expr_invalid_typeParameter_asPrefix() {
     variablesWithNotConstInitializers.add('f');
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T> {
   final f = T.k;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  final dynamic f = $$invalidConstExpr$$;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  final dynamic f = $$invalidConstExpr$$;
+}
+''');
+    }
   }
 
   test_field_covariant() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   covariant int x;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  covariant int x;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  covariant int x;
+}
+''');
+    }
   }
 
   test_field_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   /**
    * Docs
    */
   var x;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  /**
+   * Docs
+   */
+  dynamic x;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  /**
+   * Docs
+   */
+  dynamic x;
+}
+''');
+    }
   }
 
   test_field_formal_param_inferred_type_implicit() {
-    checkLibrary('class C extends D { var v; C(this.v); }'
+    var library = checkLibrary('class C extends D { var v; C(this.v); }'
         ' abstract class D { int get v; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  int v;
+  C(int this.v);
+}
+abstract class D {
+  int get v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  dynamic v;
+  C(dynamic this.v);
+}
+abstract class D {
+  int get v;
+}
+''');
+    }
   }
 
   test_field_inferred_type_nonStatic_explicit_initialized() {
-    checkLibrary('class C { num v = 0; }');
+    var library = checkLibrary('class C { num v = 0; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  num v;
+}
+''');
+    }
   }
 
   test_field_inferred_type_nonStatic_implicit_initialized() {
-    checkLibrary('class C { var v = 0; }');
+    var library = checkLibrary('class C { var v = 0; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic v;
+}
+''');
+    }
   }
 
   test_field_inferred_type_nonStatic_implicit_uninitialized() {
-    checkLibrary(
+    var library = checkLibrary(
         'class C extends D { var v; } abstract class D { int get v; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  int v;
+}
+abstract class D {
+  int get v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  dynamic v;
+}
+abstract class D {
+  int get v;
+}
+''');
+    }
   }
 
   test_field_inferred_type_static_implicit_initialized() {
-    checkLibrary('class C { static var v = 0; }');
+    var library = checkLibrary('class C { static var v = 0; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static int v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static dynamic v;
+}
+''');
+    }
   }
 
   test_field_propagatedType_const_noDep() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   static const x = 0;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const int x = 0;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static const dynamic x = 0;
+}
+''');
+    }
   }
 
   test_field_propagatedType_final_dep_inLib() {
     addLibrarySource('/a.dart', 'final a = 1;');
-    checkLibrary('''
+    var library = checkLibrary('''
 import "a.dart";
 class C {
   final b = a / 2;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class C {
+  final num b = a / 2;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class C {
+  final dynamic b = a / 2;
+}
+''');
+    }
   }
 
   test_field_propagatedType_final_dep_inPart() {
     addSource('/a.dart', 'part of lib; final a = 1;');
-    checkLibrary('''
+    var library = checkLibrary('''
 library lib;
 part "a.dart";
 class C {
   final b = a / 2;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library lib;
+part 'a.dart';
+class C {
+  final num b = a / 2;
+}
+--------------------
+unit: a.dart
+
+final int a;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library lib;
+part 'a.dart';
+class C {
+  final dynamic b = a / 2;
+}
+--------------------
+unit: a.dart
+
+final dynamic a;
+''');
+    }
   }
 
   test_field_propagatedType_final_noDep_instance() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   final x = 0;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final int x = 0;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  final dynamic x = 0;
+}
+''');
+    }
   }
 
   test_field_propagatedType_final_noDep_static() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   static final x = 0;
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static final int x;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static final dynamic x;
+}
+''');
+    }
   }
 
   test_field_static_final_untyped() {
-    checkLibrary('class C { static final x = 0; }');
+    var library = checkLibrary('class C { static final x = 0; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static final int x;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static final dynamic x;
+}
+''');
+    }
   }
 
   test_field_untyped() {
-    checkLibrary('class C { var x = 0; }');
+    var library = checkLibrary('class C { var x = 0; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int x;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+}
+''');
+    }
   }
 
   test_function_async() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'dart:async';
 Future f() async {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+Future<dynamic> f() async {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+Future<dynamic> f() async {}
+''');
+    }
   }
 
   test_function_asyncStar() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'dart:async';
 Stream f() async* {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+Stream<dynamic> f() async* {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+Stream<dynamic> f() async* {}
+''');
+    }
   }
 
   test_function_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 f() {}''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    }
   }
 
   test_function_entry_point() {
-    checkLibrary('main() {}');
+    var library = checkLibrary('main() {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic main() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic main() {}
+''');
+    }
   }
 
   test_function_entry_point_in_export() {
     addLibrarySource('/a.dart', 'library a; main() {}');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_function_entry_point_in_export_hidden() {
     addLibrarySource('/a.dart', 'library a; main() {}');
-    checkLibrary('export "a.dart" hide main;');
+    var library = checkLibrary('export "a.dart" hide main;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart' hide main;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart' hide main;
+''');
+    }
   }
 
   test_function_entry_point_in_part() {
     addSource('/a.dart', 'part of my.lib; main() {}');
-    checkLibrary('library my.lib; part "a.dart";');
+    var library = checkLibrary('library my.lib; part "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+dynamic main() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+dynamic main() {}
+''');
+    }
   }
 
   test_function_external() {
-    checkLibrary('external f();');
+    var library = checkLibrary('external f();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+external dynamic f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+external dynamic f() {}
+''');
+    }
   }
 
   test_function_parameter_final() {
-    checkLibrary('f(final x) {}');
+    var library = checkLibrary('f(final x) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f(final dynamic x) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f(final dynamic x) {}
+''');
+    }
   }
 
   test_function_parameter_kind_named() {
-    checkLibrary('f({x}) {}');
+    var library = checkLibrary('f({x}) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f({dynamic x}) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f({dynamic x}) {}
+''');
+    }
   }
 
   test_function_parameter_kind_positional() {
-    checkLibrary('f([x]) {}');
+    var library = checkLibrary('f([x]) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f([dynamic x]) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f([dynamic x]) {}
+''');
+    }
   }
 
   test_function_parameter_kind_required() {
-    checkLibrary('f(x) {}');
+    var library = checkLibrary('f(x) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f(dynamic x) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f(dynamic x) {}
+''');
+    }
   }
 
   test_function_parameter_parameters() {
-    checkLibrary('f(g(x, y)) {}');
+    var library = checkLibrary('f(g(x, y)) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f((dynamic, dynamic) → dynamic g) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f((dynamic, dynamic) → dynamic g) {}
+''');
+    }
   }
 
   test_function_parameter_return_type() {
-    checkLibrary('f(int g()) {}');
+    var library = checkLibrary('f(int g()) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f(() → int g) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f(() → int g) {}
+''');
+    }
   }
 
   test_function_parameter_return_type_void() {
-    checkLibrary('f(void g()) {}');
+    var library = checkLibrary('f(void g()) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f(() → void g) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f(() → void g) {}
+''');
+    }
   }
 
   test_function_parameter_type() {
-    checkLibrary('f(int i) {}');
+    var library = checkLibrary('f(int i) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f(int i) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f(int i) {}
+''');
+    }
   }
 
   test_function_parameters() {
-    checkLibrary('f(x, y) {}');
+    var library = checkLibrary('f(x, y) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f(dynamic x, dynamic y) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f(dynamic x, dynamic y) {}
+''');
+    }
   }
 
   test_function_return_type() {
-    checkLibrary('int f() => null;');
+    var library = checkLibrary('int f() => null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+int f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+int f() {}
+''');
+    }
   }
 
   test_function_return_type_implicit() {
-    checkLibrary('f() => null;');
+    var library = checkLibrary('f() => null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    }
   }
 
   test_function_return_type_void() {
-    checkLibrary('void f() {}');
+    var library = checkLibrary('void f() {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void f() {}
+''');
+    }
   }
 
   test_function_type_parameter() {
     prepareAnalysisContext(createOptions());
-    checkLibrary('T f<T, U>(U u) => null;');
+    var library = checkLibrary('T f<T, U>(U u) => null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+T f<T, U>(U u) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+T f<T, U>(U u) {}
+''');
+    }
   }
 
   test_function_type_parameter_with_function_typed_parameter() {
     prepareAnalysisContext(createOptions());
-    checkLibrary('void f<T, U>(T x(U u)) {}');
+    var library = checkLibrary('void f<T, U>(T x(U u)) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>((U) → T x) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>((U) → T x) {}
+''');
+    }
   }
 
   test_functions() {
-    checkLibrary('f() {} g() {}');
+    var library = checkLibrary('f() {} g() {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+dynamic g() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+dynamic g() {}
+''');
+    }
   }
 
   test_futureOr() {
     var library = checkLibrary('import "dart:async"; FutureOr<int> x;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+FutureOr<int> x;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+dynamic x;
+''');
+    }
     var variables = library.definingCompilationUnit.topLevelVariables;
     expect(variables, hasLength(1));
     if (createOptions().strongMode) {
@@ -3354,6 +7954,21 @@
 
   test_futureOr_const() {
     var library = checkLibrary('import "dart:async"; const x = FutureOr;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+const Type x = FutureOr;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+const dynamic x = FutureOr;
+''');
+    }
     var variables = library.definingCompilationUnit.topLevelVariables;
     expect(variables, hasLength(1));
     var x = variables[0] as ConstTopLevelVariableElementImpl;
@@ -3372,6 +7987,25 @@
 var x = f();
 var y = x.then((z) => z.asDouble());
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+FutureOr<int> x;
+dynamic y;
+FutureOr<int> f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+dynamic x;
+dynamic y;
+dynamic f() {}
+''');
+    }
     var variables = library.definingCompilationUnit.topLevelVariables;
     expect(variables, hasLength(2));
     var x = variables[0];
@@ -3389,7 +8023,7 @@
 
   test_generic_gClass_gMethodStatic() {
     prepareAnalysisContext(createOptions());
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T, U> {
   static void m<V, W>(V v, W w) {
     void f<X, Y>(V v, W w, X x, Y y) {
@@ -3397,6 +8031,23 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  static void m<V, W>(V v, W w) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  static void m<V, W>(V v, W w) {}
+}
+''');
+    }
   }
 
   test_getElement_constructor_named() {
@@ -3482,33 +8133,133 @@
   }
 
   test_getter_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 get x => null;''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+dynamic get x {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+dynamic get x {}
+''');
+    }
   }
 
   test_getter_external() {
-    checkLibrary('external int get x;');
+    var library = checkLibrary('external int get x;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+external int get x {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+external int get x {}
+''');
+    }
   }
 
   test_getter_inferred_type_nonStatic_implicit_return() {
-    checkLibrary(
+    var library = checkLibrary(
         'class C extends D { get f => null; } abstract class D { int get f; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  int get f {}
+}
+abstract class D {
+  int get f;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  dynamic get f {}
+}
+abstract class D {
+  int get f;
+}
+''');
+    }
   }
 
   test_getters() {
-    checkLibrary('int get x => null; get y => null;');
+    var library = checkLibrary('int get x => null; get y => null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+int get x {}
+dynamic get y {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+int get x {}
+dynamic get y {}
+''');
+    }
   }
 
   test_implicitTopLevelVariable_getterFirst() {
-    checkLibrary('int get x => 0; void set x(int value) {}');
+    var library = checkLibrary('int get x => 0; void set x(int value) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+int get x {}
+void set x(int value) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+int get x {}
+void set x(int value) {}
+''');
+    }
   }
 
   test_implicitTopLevelVariable_setterFirst() {
-    checkLibrary('void set x(int value) {} int get x => 0;');
+    var library = checkLibrary('void set x(int value) {} int get x => 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void set x(int value) {}
+int get x {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void set x(int value) {}
+int get x {}
+''');
+    }
   }
 
   test_import_configurations_useDefault() {
@@ -3523,6 +8274,23 @@
 
 class B extends A {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class B extends A {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+class B extends A {
+}
+''');
+    }
     var typeA = library.definingCompilationUnit.getType('B').supertype;
     expect(typeA.element.source.shortName, 'foo.dart');
   }
@@ -3540,28 +8308,108 @@
 
 class B extends A {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo_io.dart';
+class B extends A {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo_io.dart';
+class B extends A {
+}
+''');
+    }
     var typeA = library.definingCompilationUnit.getType('B').supertype;
     expect(typeA.element.source.shortName, 'foo_io.dart');
   }
 
   test_import_deferred() {
     addLibrarySource('/a.dart', 'f() {}');
-    checkLibrary('import "a.dart" deferred as p; main() { p.f(); }');
+    var library =
+        checkLibrary('import "a.dart" deferred as p; main() { p.f(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' deferred as p;
+dynamic main() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' deferred as p;
+dynamic main() {}
+''');
+    }
   }
 
   test_import_hide() {
     addLibrary('dart:async');
-    checkLibrary('import "dart:async" hide Stream, Completer; Future f;');
+    var library =
+        checkLibrary('import "dart:async" hide Stream, Completer; Future f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' hide Stream, Completer;
+Future<dynamic> f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' hide Stream, Completer;
+Future<dynamic> f;
+''');
+    }
   }
 
   test_import_multiple_combinators() {
     addLibrary('dart:async');
-    checkLibrary('import "dart:async" hide Stream show Future; Future f;');
+    var library =
+        checkLibrary('import "dart:async" hide Stream show Future; Future f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' hide Stream show Future;
+Future<dynamic> f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' hide Stream show Future;
+Future<dynamic> f;
+''');
+    }
   }
 
   test_import_prefixed() {
     addLibrarySource('/a.dart', 'library a; class C {}');
-    checkLibrary('import "a.dart" as a; a.C c;');
+    var library = checkLibrary('import "a.dart" as a; a.C c;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as a;
+C c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as a;
+C c;
+''');
+    }
   }
 
   test_import_self() {
@@ -3574,6 +8422,27 @@
     expect(resynthesized.imports[0].importedLibrary.location,
         resynthesized.location);
     expect(resynthesized.imports[1].importedLibrary.isDartCore, true);
+    if (isStrongMode) {
+      checkElementText(
+          resynthesized,
+          r'''
+import 'test.dart' as p;
+class C {
+}
+class D extends C {
+}
+''');
+    } else {
+      checkElementText(
+          resynthesized,
+          r'''
+import 'test.dart' as p;
+class C {
+}
+class D extends C {
+}
+''');
+    }
   }
 
   test_import_short_absolute() {
@@ -3582,78 +8451,212 @@
     var destinationPath =
         resourceProvider.pathContext.fromUri(Uri.parse('/a.dart'));
     addLibrarySource(destinationPath, 'class C {}');
-    checkLibrary('import "/a.dart"; C c;');
+    var library = checkLibrary('import "/a.dart"; C c;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import '/a.dart';
+C c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import '/a.dart';
+C c;
+''');
+    }
   }
 
   test_import_show() {
     addLibrary('dart:async');
-    checkLibrary('''
+    var library = checkLibrary('''
 import "dart:async" show Future, Stream;
 Future f;
 Stream s;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' show Future, Stream;
+Future<dynamic> f;
+Stream<dynamic> s;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' show Future, Stream;
+Future<dynamic> f;
+Stream<dynamic> s;
+''');
+    }
   }
 
   test_imports() {
     addLibrarySource('/a.dart', 'library a; class C {}');
     addLibrarySource('/b.dart', 'library b; class D {}');
-    checkLibrary('import "a.dart"; import "b.dart"; C c; D d;');
+    var library = checkLibrary('import "a.dart"; import "b.dart"; C c; D d;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+import 'b.dart';
+C c;
+D d;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+import 'b.dart';
+C c;
+D d;
+''');
+    }
   }
 
   test_inferred_function_type_for_variable_in_generic_function() {
     // In the code below, `x` has an inferred type of `() => int`, with 2
     // (unused) type parameters from the enclosing top level function.
-    checkLibrary('''
+    var library = checkLibrary('''
 f<U, V>() {
   var x = () => 0;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f<U, V>() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f<U, V>() {}
+''');
+    }
   }
 
   test_inferred_function_type_in_generic_class_constructor() {
     // In the code below, `() => () => 0` has an inferred return type of
     // `() => int`, with 2 (unused) type parameters from the enclosing class.
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<U, V> {
   final x;
   C() : x = (() => () => 0);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<U, V> {
+  final dynamic x;
+  C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<U, V> {
+  final dynamic x;
+  C();
+}
+''');
+    }
   }
 
   test_inferred_function_type_in_generic_class_getter() {
     // In the code below, `() => () => 0` has an inferred return type of
     // `() => int`, with 2 (unused) type parameters from the enclosing class.
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<U, V> {
   get x => () => () => 0;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<U, V> {
+  dynamic get x {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<U, V> {
+  dynamic get x {}
+}
+''');
+    }
   }
 
   test_inferred_function_type_in_generic_class_in_generic_method() {
     // In the code below, `() => () => 0` has an inferred return type of
     // `() => int`, with 3 (unused) type parameters from the enclosing class
     // and method.
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T> {
   f<U, V>() {
     print(() => () => 0);
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  dynamic f<U, V>() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  dynamic f<U, V>() {}
+}
+''');
+    }
   }
 
   test_inferred_function_type_in_generic_class_setter() {
     // In the code below, `() => () => 0` has an inferred return type of
     // `() => int`, with 2 (unused) type parameters from the enclosing class.
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<U, V> {
   void set x(value) {
     print(() => () => 0);
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<U, V> {
+  void set x(dynamic value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<U, V> {
+  void set x(dynamic value) {}
+}
+''');
+    }
   }
 
   test_inferred_function_type_in_generic_closure() {
@@ -3668,11 +8671,23 @@
     }
     // In the code below, `<U, V>() => () => 0` has an inferred return type of
     // `() => int`, with 3 (unused) type parameters.
-    checkLibrary('''
+    var library = checkLibrary('''
 f<T>() {
   print(/*<U, V>*/() => () => 0);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f<T>() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+''');
+    }
   }
 
   test_inferred_generic_function_type_in_generic_closure() {
@@ -3687,35 +8702,136 @@
     }
     // In the code below, `<U, V>() => <W, X, Y, Z>() => 0` has an inferred
     // return type of `() => int`, with 7 (unused) type parameters.
-    checkLibrary('''
+    var library = checkLibrary('''
 f<T>() {
   print(/*<U, V>*/() => /*<W, X, Y, Z>*/() => 0);
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f<T>() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+''');
+    }
   }
 
   test_inferred_type_is_typedef() {
-    checkLibrary('typedef int F(String s);'
+    var library = checkLibrary('typedef int F(String s);'
         ' class C extends D { var v; }'
         ' abstract class D { F get v; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef int F(String s);
+class C extends D {
+  F v;
+}
+abstract class D {
+  F get v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef int F(String s);
+class C extends D {
+  dynamic v;
+}
+abstract class D {
+  F get v;
+}
+''');
+    }
   }
 
   test_inferred_type_refers_to_bound_type_param() {
-    checkLibrary('class C<T> extends D<int, T> { var v; }'
+    var library = checkLibrary('class C<T> extends D<int, T> { var v; }'
         ' abstract class D<U, V> { Map<V, U> get v; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> extends D<int, T> {
+  Map<T, int> v;
+}
+abstract class D<U, V> {
+  Map<V, U> get v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> extends D<int, T> {
+  dynamic v;
+}
+abstract class D<U, V> {
+  Map<V, U> get v;
+}
+''');
+    }
   }
 
   void test_inferred_type_refers_to_function_typed_param_of_typedef() {
-    checkLibrary('''
+    var library = checkLibrary('''
 typedef void F(int g(String s));
 h(F f) => null;
 var v = h(/*info:INFERRED_TYPE_CLOSURE*/(y) {});
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef void F((String) → int g);
+dynamic v;
+dynamic h(F f) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef void F((String) → int g);
+dynamic v;
+dynamic h(F f) {}
+''');
+    }
   }
 
   test_inferred_type_refers_to_function_typed_parameter_type_generic_class() {
-    checkLibrary('class C<T, U> extends D<U, int> { void f(int x, g) {} }'
-        ' abstract class D<V, W> { void f(int x, W g(V s)); }');
+    var library =
+        checkLibrary('class C<T, U> extends D<U, int> { void f(int x, g) {} }'
+            ' abstract class D<V, W> { void f(int x, W g(V s)); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> extends D<U, int> {
+  void f(int x, (U) → int g) {}
+}
+abstract class D<V, W> {
+  void f(int x, (V) → W g);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> extends D<U, int> {
+  void f(int x, dynamic g) {}
+}
+abstract class D<V, W> {
+  void f(int x, (V) → W g);
+}
+''');
+    }
   }
 
   test_inferred_type_refers_to_function_typed_parameter_type_other_lib() {
@@ -3723,31 +8839,127 @@
         '/a.dart', 'import "b.dart"; abstract class D extends E {}');
     addLibrarySource(
         '/b.dart', 'abstract class E { void f(int x, int g(String s)); }');
-    checkLibrary('import "a.dart"; class C extends D { void f(int x, g) {} }');
+    var library = checkLibrary(
+        'import "a.dart"; class C extends D { void f(int x, g) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class C extends D {
+  void f(int x, (String) → int g) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class C extends D {
+  void f(int x, dynamic g) {}
+}
+''');
+    }
   }
 
   test_inferred_type_refers_to_method_function_typed_parameter_type() {
-    checkLibrary('class C extends D { void f(int x, g) {} }'
+    var library = checkLibrary('class C extends D { void f(int x, g) {} }'
         ' abstract class D { void f(int x, int g(String s)); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void f(int x, (String) → int g) {}
+}
+abstract class D {
+  void f(int x, (String) → int g);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void f(int x, dynamic g) {}
+}
+abstract class D {
+  void f(int x, (String) → int g);
+}
+''');
+    }
   }
 
   test_inferred_type_refers_to_nested_function_typed_param() {
-    checkLibrary('''
+    var library = checkLibrary('''
 f(void g(int x, void h())) => null;
 var v = f((x, y) {});
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+dynamic f((int, () → void) → void g) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+dynamic f((int, () → void) → void g) {}
+''');
+    }
   }
 
   test_inferred_type_refers_to_nested_function_typed_param_named() {
-    checkLibrary('''
+    var library = checkLibrary('''
 f({void g(int x, void h())}) => null;
 var v = f(g: (x, y) {});
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+dynamic f({(int, () → void) → void g}) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+dynamic f({(int, () → void) → void g}) {}
+''');
+    }
   }
 
   test_inferred_type_refers_to_setter_function_typed_parameter_type() {
-    checkLibrary('class C extends D { void set f(g) {} }'
+    var library = checkLibrary('class C extends D { void set f(g) {} }'
         ' abstract class D { void set f(int g(String s)); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void set f((String) → int g) {}
+}
+abstract class D {
+  void set f((String) → int g);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void set f(dynamic g) {}
+}
+abstract class D {
+  void set f((String) → int g);
+}
+''');
+    }
   }
 
   void test_inferredType_definedInSdkLibraryPart() {
@@ -3765,6 +8977,25 @@
   m(p) {}
 }
   ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class B extends A {
+  dynamic m(Stream<dynamic> p) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+class B extends A {
+  dynamic m(dynamic p) {}
+}
+''');
+    }
     ClassElement b = library.definingCompilationUnit.types[0];
     ParameterElement p = b.methods[0].parameters[0];
     // This test should verify that we correctly record inferred types,
@@ -3777,15 +9008,32 @@
   }
 
   void test_inferredType_usesSyntheticFunctionType_functionTypedParam() {
-    checkLibrary('''
+    var library = checkLibrary('''
 int f(int x(String y)) => null;
 String g(int x(String y)) => null;
 var v = [f, g];
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+List<((String) → int) → Object> v;
+int f((String) → int x) {}
+String g((String) → int x) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+int f((String) → int x) {}
+String g((String) → int x) {}
+''');
+    }
   }
 
   test_inheritance_errors() {
-    checkLibrary('''
+    var library = checkLibrary('''
 abstract class A {
   int m();
 }
@@ -3800,63 +9048,214 @@
   var f;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+abstract class A {
+  int m();
+}
+abstract class B {
+  String m();
+}
+abstract class C implements A, B {
+}
+abstract class D extends C {
+  dynamic f;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+abstract class A {
+  int m();
+}
+abstract class B {
+  String m();
+}
+abstract class C implements A, B {
+}
+abstract class D extends C {
+  dynamic f;
+}
+''');
+    }
   }
 
   test_initializer_executable_with_return_type_from_closure() {
-    checkLibrary('var v = () => 0;');
+    var library = checkLibrary('var v = () => 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+() → int v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+''');
+    }
   }
 
   test_initializer_executable_with_return_type_from_closure_await_dynamic() {
-    checkLibrary('var v = (f) async => await f;');
+    var library = checkLibrary('var v = (f) async => await f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+(dynamic) → Future<dynamic> v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+''');
+    }
   }
 
   test_initializer_executable_with_return_type_from_closure_await_future3_int() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'dart:async';
 var v = (Future<Future<Future<int>>> f) async => await f;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+(Future<Future<Future<int>>>) → Future<int> v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+dynamic v;
+''');
+    }
   }
 
   test_initializer_executable_with_return_type_from_closure_await_future_int() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'dart:async';
 var v = (Future<int> f) async => await f;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+(Future<int>) → Future<int> v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+dynamic v;
+''');
+    }
   }
 
   test_initializer_executable_with_return_type_from_closure_await_future_noArg() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'dart:async';
 var v = (Future f) async => await f;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+(Future<dynamic>) → Future<dynamic> v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+dynamic v;
+''');
+    }
   }
 
   test_initializer_executable_with_return_type_from_closure_field() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   var v = () => 0;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  () → int v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic v;
+}
+''');
+    }
   }
 
   test_initializer_executable_with_return_type_from_closure_local() {
-    checkLibrary('''
+    var library = checkLibrary('''
 void f() {
   int u = 0;
   var v = () => 0;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void f() {}
+''');
+    }
   }
 
   test_instantiateToBounds_boundRefersToEarlierTypeArgument() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<S extends num, T extends C<S, T>> {}
 C c;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<S extends num, T extends C<S, T>> {
+}
+C<num, C<num, dynamic>> c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<S extends num, T extends C<S, T>> {
+}
+C<dynamic, dynamic> c;
+''');
+    }
   }
 
   test_instantiateToBounds_boundRefersToItself() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T extends C<T>> {}
 C c;
 var c2 = new C();
@@ -3864,27 +9263,101 @@
   var c3 = new C();
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T extends C<T>> {
+}
+class B {
+  C<C<dynamic>> c3;
+}
+C<C<dynamic>> c;
+C<C<dynamic>> c2;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T extends C<T>> {
+}
+class B {
+  dynamic c3;
+}
+C<dynamic> c;
+dynamic c2;
+''');
+    }
   }
 
   test_instantiateToBounds_boundRefersToLaterTypeArgument() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T extends C<T, U>, U extends num> {}
 C c;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T extends C<T, U>, U extends num> {
+}
+C<C<dynamic, num>, num> c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T extends C<T, U>, U extends num> {
+}
+C<dynamic, dynamic> c;
+''');
+    }
   }
 
   test_instantiateToBounds_functionTypeAlias_simple() {
-    checkLibrary('''
+    var library = checkLibrary('''
 typedef F<T extends num>(T p);
 F f;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<T extends num>(T p);
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<T extends num>(T p);
+F f;
+''');
+    }
   }
 
   test_instantiateToBounds_simple() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T extends num> {}
 C c;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T extends num> {
+}
+C<num> c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T extends num> {
+}
+C<dynamic> c;
+''');
+    }
   }
 
   test_invalid_annotation_prefixed_constructor() {
@@ -3895,11 +9368,30 @@
   const C.named();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import "a.dart" as a;
 @a.C.named
 class D {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as a;
+@a.C.named
+class D {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as a;
+@a.C.named
+class D {
+}
+''');
+    }
   }
 
   test_invalid_annotation_unprefixed_constructor() {
@@ -3910,31 +9402,86 @@
   const C.named();
 }
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import "a.dart";
 @C.named
 class D {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+@C.named
+class D {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+@C.named
+class D {
+}
+''');
+    }
   }
 
   test_invalid_importPrefix_asTypeArgument() {
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'dart:async' as ppp;
 class C {
   List<ppp> v;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as ppp;
+class C {
+  List<dynamic> v;
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as ppp;
+class C {
+  List<dynamic> v;
+}
+''');
+    }
   }
 
   test_invalid_nameConflict_imported() {
     namesThatCannotBeResolved.add('V');
     addLibrarySource('/a.dart', 'V() {}');
     addLibrarySource('/b.dart', 'V() {}');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'a.dart';
 import 'b.dart';
 foo([p = V]) {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+import 'b.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+import 'b.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+    }
   }
 
   test_invalid_nameConflict_imported_exported() {
@@ -3947,41 +9494,109 @@
 export 'a.dart';
 export 'b.dart';
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'c.dart';
 foo([p = V]) {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'c.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'c.dart';
+dynamic foo([dynamic p = V]) {}
+''');
+    }
   }
 
   test_invalid_nameConflict_local() {
     namesThatCannotBeResolved.add('V');
-    checkLibrary('''
+    var library = checkLibrary('''
 foo([p = V]) {}
 V() {}
 var V;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic V;
+dynamic foo([dynamic p = V]) {}
+dynamic V() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic V;
+dynamic foo([dynamic p = V]) {}
+dynamic V() {}
+''');
+    }
   }
 
   test_invalid_setterParameter_fieldFormalParameter() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   int foo;
   void set bar(this.foo) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int foo;
+  void set bar(dynamic this.foo) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  int foo;
+  void set bar(dynamic this.foo) {}
+}
+''');
+    }
   }
 
   test_invalid_setterParameter_fieldFormalParameter_self() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   set x(this.x) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(dynamic this.x) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic set x(dynamic this.x) {}
+}
+''');
+    }
   }
 
   test_invalidUris() {
     allowMissingFiles = true;
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import '[invalid uri]';
 import '[invalid uri]:foo.dart';
 import 'a1.dart';
@@ -3998,31 +9613,104 @@
 part 'a3.dart';
 part '[invalid uri]';
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a1.dart';
+export 'a2.dart';
+part 'a3.dart';
+--------------------
+unit: a3.dart
+
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a1.dart';
+export 'a2.dart';
+part 'a3.dart';
+--------------------
+unit: a3.dart
+
+''');
+    }
   }
 
   test_library() {
-    checkLibrary('');
+    var library = checkLibrary('');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+''');
+    }
   }
 
   test_library_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 library foo;''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library foo;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library foo;
+''');
+    }
   }
 
   test_library_name_with_spaces() {
-    checkLibrary('library foo . bar ;');
+    var library = checkLibrary('library foo . bar ;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library foo.bar;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library foo.bar;
+''');
+    }
   }
 
   test_library_named() {
-    checkLibrary('library foo.bar;');
+    var library = checkLibrary('library foo.bar;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library foo.bar;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library foo.bar;
+''');
+    }
   }
 
   test_localFunctions() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 f() {
   f1() {}
   {
@@ -4030,38 +9718,98 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    }
   }
 
   test_localFunctions_inConstructor() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   C() {
     f() {}
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    }
   }
 
   test_localFunctions_inMethod() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   m() {
     f() {}
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic m() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic m() {}
+}
+''');
+    }
   }
 
   test_localFunctions_inTopLevelGetter() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 get g {
   f() {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic get g {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic get g {}
+''');
+    }
   }
 
   test_localLabels_inConstructor() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 class C {
   C() {
@@ -4074,10 +9822,27 @@
 }
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    }
   }
 
   test_localLabels_inMethod() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 class C {
   m() {
@@ -4090,10 +9855,27 @@
 }
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic m() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic m() {}
+}
+''');
+    }
   }
 
   test_localLabels_inTopLevelFunction() {
-    checkLibrary(
+    var library = checkLibrary(
         r'''
 main() {
   aaa: while (true) {}
@@ -4104,10 +9886,23 @@
 }
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic main() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic main() {}
+''');
+    }
   }
 
   test_localVariables_inConstructor() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   C() {
     int v;
@@ -4115,10 +9910,27 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C();
+}
+''');
+    }
   }
 
   test_localVariables_inLocalFunction() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 f() {
   f1() {
     int v1 = 1;
@@ -4131,20 +9943,50 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+''');
+    }
   }
 
   test_localVariables_inMethod() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class C {
   m() {
     int v;
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic m() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic m() {}
+}
+''');
+    }
   }
 
   test_localVariables_inTopLevelFunction() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 main() {
   int v1 = 1;
   {
@@ -4153,260 +9995,1295 @@
   Map<int, List<double>> v3;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic main() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic main() {}
+''');
+    }
   }
 
   test_localVariables_inTopLevelGetter() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 get g {
   int v;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic get g {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic get g {}
+''');
+    }
   }
 
   test_main_class() {
-    checkLibrary('class main {}');
+    var library = checkLibrary('class main {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class main {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class main {
+}
+''');
+    }
   }
 
   test_main_class_alias() {
-    checkLibrary('class main = C with D; class C {} class D {}');
+    var library = checkLibrary('class main = C with D; class C {} class D {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class alias main extends C with D {
+  synthetic main() = C;
+}
+class C {
+}
+class D {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class alias main extends C with D {
+  synthetic main() = C;
+}
+class C {
+}
+class D {
+}
+''');
+    }
   }
 
   test_main_class_alias_via_export() {
     addLibrarySource('/a.dart', 'class main = C with D; class C {} class D {}');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_main_class_via_export() {
     addLibrarySource('/a.dart', 'class main {}');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_main_getter() {
-    checkLibrary('get main => null;');
+    var library = checkLibrary('get main => null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic get main {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic get main {}
+''');
+    }
   }
 
   test_main_getter_via_export() {
     addLibrarySource('/a.dart', 'get main => null;');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_main_typedef() {
-    checkLibrary('typedef main();');
+    var library = checkLibrary('typedef main();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic main();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic main();
+''');
+    }
   }
 
   test_main_typedef_via_export() {
     addLibrarySource('/a.dart', 'typedef main();');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_main_variable() {
-    checkLibrary('var main;');
+    var library = checkLibrary('var main;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic main;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic main;
+''');
+    }
   }
 
   test_main_variable_via_export() {
     addLibrarySource('/a.dart', 'var main;');
-    checkLibrary('export "a.dart";');
+    var library = checkLibrary('export "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'a.dart';
+''');
+    }
   }
 
   test_member_function_async() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'dart:async';
 class C {
   Future f() async {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+class C {
+  Future<dynamic> f() async {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+class C {
+  Future<dynamic> f() async {}
+}
+''');
+    }
   }
 
   test_member_function_asyncStar() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 import 'dart:async';
 class C {
   Stream f() async* {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+class C {
+  Stream<dynamic> f() async* {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async';
+class C {
+  Stream<dynamic> f() async* {}
+}
+''');
+    }
   }
 
   test_metadata_classDeclaration() {
-    checkLibrary('const a = null; @a class C {}');
+    var library = checkLibrary(r'''
+const a = null;
+const b = null;
+@a
+@b
+class C {}''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@a
+@b
+class C {
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@a
+@b
+class C {
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+    }
   }
 
   test_metadata_classTypeAlias() {
-    checkLibrary(
+    var library = checkLibrary(
         'const a = null; @a class C = D with E; class D {} class E {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@a
+class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@a
+class alias C extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_constructor_call_named() {
-    checkLibrary('class A { const A.named(); } @A.named() class C {}');
+    var library =
+        checkLibrary('class A { const A.named(); } @A.named() class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A.named();
+}
+@A.named()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A.named();
+}
+@A.named()
+class C {
+}
+''');
+    }
   }
 
   test_metadata_constructor_call_named_prefixed() {
     addLibrarySource('/foo.dart', 'class A { const A.named(); }');
-    checkLibrary('import "foo.dart" as foo; @foo.A.named() class C {}');
+    var library =
+        checkLibrary('import "foo.dart" as foo; @foo.A.named() class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+@A.named()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+@A.named()
+class C {
+}
+''');
+    }
   }
 
   test_metadata_constructor_call_unnamed() {
-    checkLibrary('class A { const A(); } @A() class C {}');
+    var library = checkLibrary('class A { const A(); } @A() class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A();
+}
+@A()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A();
+}
+@A()
+class C {
+}
+''');
+    }
   }
 
   test_metadata_constructor_call_unnamed_prefixed() {
     addLibrarySource('/foo.dart', 'class A { const A(); }');
-    checkLibrary('import "foo.dart" as foo; @foo.A() class C {}');
+    var library = checkLibrary('import "foo.dart" as foo; @foo.A() class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+@A()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart' as foo;
+@A()
+class C {
+}
+''');
+    }
   }
 
   test_metadata_constructor_call_with_args() {
-    checkLibrary('class A { const A(x); } @A(null) class C {}');
+    var library = checkLibrary('class A { const A(x); } @A(null) class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A(dynamic x);
+}
+@A(null)
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A(dynamic x);
+}
+@A(null)
+class C {
+}
+''');
+    }
   }
 
   test_metadata_constructorDeclaration_named() {
-    checkLibrary('const a = null; class C { @a C.named(); }');
+    var library = checkLibrary('const a = null; class C { @a C.named(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  C.named();
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  C.named();
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_constructorDeclaration_unnamed() {
-    checkLibrary('const a = null; class C { @a C(); }');
+    var library = checkLibrary('const a = null; class C { @a C(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  C();
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  C();
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_enumDeclaration() {
-    checkLibrary('const a = null; @a enum E { v }');
+    var library = checkLibrary('const a = null; @a enum E { v }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@a
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@a
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_exportDirective() {
     addLibrarySource('/foo.dart', '');
-    checkLibrary('@a export "foo.dart"; const a = null;');
+    var library = checkLibrary('@a export "foo.dart"; const a = null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@a
+export 'foo.dart';
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@a
+export 'foo.dart';
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_fieldDeclaration() {
-    checkLibrary('const a = null; class C { @a int x; }');
+    var library = checkLibrary('const a = null; class C { @a int x; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  int x;
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  int x;
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_fieldFormalParameter() {
-    checkLibrary('const a = null; class C { var x; C(@a this.x); }');
+    var library =
+        checkLibrary('const a = null; class C { var x; C(@a this.x); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(@a dynamic this.x);
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C(@a dynamic this.x);
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_fieldFormalParameter_withDefault() {
-    checkLibrary('const a = null; class C { var x; C([@a this.x = null]); }');
+    var library = checkLibrary(
+        'const a = null; class C { var x; C([@a this.x = null]); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C([@a dynamic this.x]);
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C([@a dynamic this.x]);
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_functionDeclaration_function() {
-    checkLibrary('const a = null; @a f() {}');
+    var library = checkLibrary('const a = null; @a f() {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f() {}
+''');
+    }
   }
 
   test_metadata_functionDeclaration_getter() {
-    checkLibrary('const a = null; @a get f => null;');
+    var library = checkLibrary('const a = null; @a get f => null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+@a
+dynamic get f {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+@a
+dynamic get f {}
+''');
+    }
   }
 
   test_metadata_functionDeclaration_setter() {
-    checkLibrary('const a = null; @a set f(value) {}');
+    var library = checkLibrary('const a = null; @a set f(value) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+@a
+void set f(dynamic value) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+@a
+dynamic set f(dynamic value) {}
+''');
+    }
   }
 
   test_metadata_functionTypeAlias() {
-    checkLibrary('const a = null; @a typedef F();');
+    var library = checkLibrary('const a = null; @a typedef F();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@a
+typedef dynamic F();
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@a
+typedef dynamic F();
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_functionTypedFormalParameter() {
-    checkLibrary('const a = null; f(@a g()) {}');
+    var library = checkLibrary('const a = null; f(@a g()) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f(@a () → dynamic g) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f(@a () → dynamic g) {}
+''');
+    }
   }
 
   test_metadata_functionTypedFormalParameter_withDefault() {
-    checkLibrary('const a = null; f([@a g() = null]) {}');
+    var library = checkLibrary('const a = null; f([@a g() = null]) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f([@a () → dynamic g = null]) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f([@a () → dynamic g = null]) {}
+''');
+    }
   }
 
   test_metadata_importDirective() {
     addLibrarySource('/foo.dart', 'const b = null;');
-    checkLibrary('@a import "foo.dart"; const a = b;');
+    var library = checkLibrary('@a import "foo.dart"; const a = b;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@a
+import 'foo.dart';
+const dynamic a = b;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@a
+import 'foo.dart';
+const dynamic a = b;
+''');
+    }
   }
 
   test_metadata_invalid_classDeclaration() {
-    checkLibrary('f(_) {} @f(42) class C {}');
+    var library = checkLibrary('f(_) {} @f(42) class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@f(42)
+class C {
+}
+dynamic f(dynamic _) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@f(42)
+class C {
+}
+dynamic f(dynamic _) {}
+''');
+    }
   }
 
   test_metadata_libraryDirective() {
-    checkLibrary('@a library L; const a = null;');
+    var library = checkLibrary('@a library L; const a = null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@a
+library L;
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@a
+library L;
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_methodDeclaration_getter() {
-    checkLibrary('const a = null; class C { @a get m => null; }');
+    var library = checkLibrary('const a = null; class C { @a get m => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  dynamic get m {}
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  dynamic get m {}
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_methodDeclaration_method() {
-    checkLibrary('const a = null; class C { @a m() {} }');
+    var library = checkLibrary(r'''
+const a = null;
+const b = null;
+class C {
+  @a
+  @b
+  m() {}
+}
+''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  @b
+  dynamic m() {}
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  @b
+  dynamic m() {}
+}
+const dynamic a = null;
+const dynamic b = null;
+''');
+    }
   }
 
   test_metadata_methodDeclaration_setter() {
-    checkLibrary('const a = null; class C { @a set m(value) {} }');
+    var library =
+        checkLibrary('const a = null; class C { @a set m(value) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  void set m(dynamic value) {}
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  @a
+  dynamic set m(dynamic value) {}
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_partDirective() {
     addSource('/foo.dart', 'part of L;');
-    checkLibrary('library L; @a part "foo.dart"; const a = null;');
+    var library =
+        checkLibrary('library L; @a part "foo.dart"; const a = null;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library L;
+@a
+part 'foo.dart';
+const dynamic a = null;
+--------------------
+unit: foo.dart
+
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library L;
+@a
+part 'foo.dart';
+const dynamic a = null;
+--------------------
+unit: foo.dart
+
+''');
+    }
   }
 
   test_metadata_prefixed_variable() {
     addLibrarySource('/a.dart', 'const b = null;');
-    checkLibrary('import "a.dart" as a; @a.b class C {}');
+    var library = checkLibrary('import "a.dart" as a; @a.b class C {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as a;
+@a.b
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart' as a;
+@a.b
+class C {
+}
+''');
+    }
   }
 
   test_metadata_simpleFormalParameter() {
-    checkLibrary('const a = null; f(@a x) {}');
+    var library = checkLibrary('const a = null; f(@a x) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f(@a dynamic x) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f(@a dynamic x) {}
+''');
+    }
   }
 
   test_metadata_simpleFormalParameter_withDefault() {
-    checkLibrary('const a = null; f([@a x = null]) {}');
+    var library = checkLibrary('const a = null; f([@a x = null]) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f([@a dynamic x = null]) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f([@a dynamic x = null]) {}
+''');
+    }
   }
 
   test_metadata_topLevelVariableDeclaration() {
-    checkLibrary('const a = null; @a int v;');
+    var library = checkLibrary('const a = null; @a int v;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+@a
+int v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+@a
+int v;
+''');
+    }
   }
 
   test_metadata_typeParameter_ofClass() {
-    checkLibrary('const a = null; class C<@a T> {}');
+    var library = checkLibrary('const a = null; class C<@a T> {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_typeParameter_ofClassTypeAlias() {
-    checkLibrary(
+    var library = checkLibrary(
         'const a = null; class C<@a T> = D with E; class D {} class E {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class alias C<T> extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class alias C<T> extends D with E {
+  synthetic C() = D;
+}
+class D {
+}
+class E {
+}
+const dynamic a = null;
+''');
+    }
   }
 
   test_metadata_typeParameter_ofFunction() {
-    checkLibrary('const a = null; f<@a T>() {}');
+    var library = checkLibrary('const a = null; f<@a T>() {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f<T>() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic a = null;
+dynamic f<T>() {}
+''');
+    }
   }
 
   test_metadata_typeParameter_ofTypedef() {
-    checkLibrary('const a = null; typedef F<@a T>();');
+    var library = checkLibrary('const a = null; typedef F<@a T>();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<T>();
+const dynamic a = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<T>();
+const dynamic a = null;
+''');
+    }
   }
 
   test_method_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   /**
    * Docs
    */
   f() {}
 }''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  /**
+   * Docs
+   */
+  dynamic f() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  /**
+   * Docs
+   */
+  dynamic f() {}
+}
+''');
+    }
   }
 
   test_method_inferred_type_nonStatic_implicit_param() {
-    checkLibrary('class C extends D { void f(value) {} }'
+    var library = checkLibrary('class C extends D { void f(value) {} }'
         ' abstract class D { void f(int value); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void f(int value) {}
+}
+abstract class D {
+  void f(int value);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void f(dynamic value) {}
+}
+abstract class D {
+  void f(int value);
+}
+''');
+    }
   }
 
   test_method_inferred_type_nonStatic_implicit_return() {
-    checkLibrary(
+    var library = checkLibrary(
         'class C extends D { f() => null; } abstract class D { int f(); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  int f() {}
+}
+abstract class D {
+  int f();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  dynamic f() {}
+}
+abstract class D {
+  int f();
+}
+''');
+    }
   }
 
   test_method_type_parameter() {
     prepareAnalysisContext(createOptions());
-    checkLibrary('class C { T f<T, U>(U u) => null; }');
+    var library = checkLibrary('class C { T f<T, U>(U u) => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  T f<T, U>(U u) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  T f<T, U>(U u) {}
+}
+''');
+    }
   }
 
   test_method_type_parameter_in_generic_class() {
     prepareAnalysisContext(createOptions());
-    checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
+    var library =
+        checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  V f<V, W>(T t, U u, W w) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  V f<V, W>(T t, U u, W w) {}
+}
+''');
+    }
   }
 
   test_method_type_parameter_with_function_typed_parameter() {
     prepareAnalysisContext(createOptions());
-    checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
+    var library = checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void f<T, U>((U) → T x) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void f<T, U>((U) → T x) {}
+}
+''');
+    }
   }
 
   test_nameConflict_exportedAndLocal() {
@@ -4418,10 +11295,25 @@
 export 'a.dart';
 class C {}
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'c.dart';
 C v = null;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'c.dart';
+C v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'c.dart';
+C v;
+''');
+    }
   }
 
   test_nameConflict_exportedAndLocal_exported() {
@@ -4434,10 +11326,25 @@
 class C {}
 ''');
     addLibrarySource('/d.dart', 'export "c.dart";');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'd.dart';
 C v = null;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'd.dart';
+C v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'd.dart';
+C v;
+''');
+    }
   }
 
   test_nameConflict_exportedAndParted() {
@@ -4456,10 +11363,25 @@
 export 'a.dart';
 part 'b.dart';
 ''');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'c.dart';
 C v = null;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'c.dart';
+C v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'c.dart';
+C v;
+''');
+    }
   }
 
   test_nameConflict_importWithRelativeUri_exportWithAbsolute() {
@@ -4469,15 +11391,32 @@
 
     addLibrarySource('/a.dart', 'class A {}');
     addLibrarySource('/b.dart', 'export "/a.dart";');
-    checkLibrary('''
+    var library = checkLibrary('''
 import 'a.dart';
 import 'b.dart';
 A v = null;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+import 'b.dart';
+A v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+import 'b.dart';
+A v;
+''');
+    }
   }
 
   test_nested_generic_functions_in_generic_class_with_function_typed_params() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T, U> {
   void g<V, W>() {
     void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
@@ -4485,10 +11424,27 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  void g<V, W>() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  void g<V, W>() {}
+}
+''');
+    }
   }
 
   test_nested_generic_functions_in_generic_class_with_local_variables() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T, U> {
   void g<V, W>() {
     void h<X, Y>() {
@@ -4502,10 +11458,27 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  void g<V, W>() {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  void g<V, W>() {}
+}
+''');
+    }
   }
 
   test_nested_generic_functions_with_function_typed_param() {
-    checkLibrary('''
+    var library = checkLibrary('''
 void f<T, U>() {
   void g<V, W>() {
     void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
@@ -4513,10 +11486,23 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>() {}
+''');
+    }
   }
 
   test_nested_generic_functions_with_local_variables() {
-    checkLibrary('''
+    var library = checkLibrary('''
 void f<T, U>() {
   void g<V, W>() {
     void h<X, Y>() {
@@ -4530,54 +11516,211 @@
   }
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>() {}
+''');
+    }
   }
 
   test_operator() {
-    checkLibrary('class C { C operator+(C other) => null; }');
+    var library = checkLibrary('class C { C operator+(C other) => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C +(C other) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C +(C other) {}
+}
+''');
+    }
   }
 
   test_operator_equal() {
-    checkLibrary('class C { bool operator==(Object other) => false; }');
+    var library =
+        checkLibrary('class C { bool operator==(Object other) => false; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool ==(Object other) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool ==(Object other) {}
+}
+''');
+    }
   }
 
   test_operator_external() {
-    checkLibrary('class C { external C operator+(C other); }');
+    var library = checkLibrary('class C { external C operator+(C other); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external C +(C other) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  external C +(C other) {}
+}
+''');
+    }
   }
 
   test_operator_greater_equal() {
-    checkLibrary('class C { bool operator>=(C other) => false; }');
+    var library =
+        checkLibrary('class C { bool operator>=(C other) => false; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool >=(C other) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool >=(C other) {}
+}
+''');
+    }
   }
 
   test_operator_index() {
-    checkLibrary('class C { bool operator[](int i) => null; }');
+    var library = checkLibrary('class C { bool operator[](int i) => null; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool [](int i) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool [](int i) {}
+}
+''');
+    }
   }
 
   test_operator_index_set() {
-    checkLibrary('class C { void operator[]=(int i, bool v) {} }');
+    var library =
+        checkLibrary('class C { void operator[]=(int i, bool v) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void []=(int i, bool v) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void []=(int i, bool v) {}
+}
+''');
+    }
   }
 
   test_operator_less_equal() {
-    checkLibrary('class C { bool operator<=(C other) => false; }');
+    var library =
+        checkLibrary('class C { bool operator<=(C other) => false; }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool <=(C other) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  bool <=(C other) {}
+}
+''');
+    }
   }
 
   void test_parameter_checked() {
     // Note: due to dartbug.com/27393, the keyword "checked" is identified by
     // its presence in a library called "meta".  If that bug is fixed, this test
     // my need to be changed.
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 library meta;
 const checked = null;
 class A<T> {
   void f(@checked T t) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library meta;
+class A<T> {
+  void f(@checked covariant T t) {}
+}
+const dynamic checked = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library meta;
+class A<T> {
+  void f(@checked covariant T t) {}
+}
+const dynamic checked = null;
+''');
+    }
   }
 
   void test_parameter_checked_inherited() {
     // Note: due to dartbug.com/27393, the keyword "checked" is identified by
     // its presence in a library called "meta".  If that bug is fixed, this test
     // my need to be changed.
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 library meta;
 const checked = null;
 class A<T> {
@@ -4587,15 +11730,59 @@
   void f(T t) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library meta;
+class A<T> {
+  void f(@checked covariant T t) {}
+}
+class B<T> extends A<T> {
+  void f(covariant T t) {}
+}
+const dynamic checked = null;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library meta;
+class A<T> {
+  void f(@checked covariant T t) {}
+}
+class B<T> extends A<T> {
+  void f(T t) {}
+}
+const dynamic checked = null;
+''');
+    }
   }
 
   test_parameter_covariant() {
     prepareAnalysisContext(createOptions());
-    checkLibrary('class C { void m(covariant C c) {} }');
+    var library = checkLibrary('class C { void m(covariant C c) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void m(covariant C c) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void m(covariant C c) {}
+}
+''');
+    }
   }
 
   void test_parameter_covariant_inherited() {
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 class A<T> {
   void f(covariant T t) {}
 }
@@ -4603,130 +11790,480 @@
   void f(T t) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A<T> {
+  void f(covariant T t) {}
+}
+class B<T> extends A<T> {
+  void f(covariant T t) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A<T> {
+  void f(covariant T t) {}
+}
+class B<T> extends A<T> {
+  void f(T t) {}
+}
+''');
+    }
   }
 
   test_parameter_parameters() {
-    checkLibrary('class C { f(g(x, y)) {} }');
+    var library = checkLibrary('class C { f(g(x, y)) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f((dynamic, dynamic) → dynamic g) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f((dynamic, dynamic) → dynamic g) {}
+}
+''');
+    }
   }
 
   test_parameter_parameters_in_generic_class() {
-    checkLibrary('class C<A, B> { f(A g(B x)) {} }');
+    var library = checkLibrary('class C<A, B> { f(A g(B x)) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<A, B> {
+  dynamic f((B) → A g) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<A, B> {
+  dynamic f((B) → A g) {}
+}
+''');
+    }
   }
 
   test_parameter_return_type() {
-    checkLibrary('class C { f(int g()) {} }');
+    var library = checkLibrary('class C { f(int g()) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f(() → int g) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f(() → int g) {}
+}
+''');
+    }
   }
 
   test_parameter_return_type_void() {
-    checkLibrary('class C { f(void g()) {} }');
+    var library = checkLibrary('class C { f(void g()) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f(() → void g) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic f(() → void g) {}
+}
+''');
+    }
   }
 
   test_parameterTypeNotInferred_constructor() {
     // Strong mode doesn't do type inference on constructor parameters, so it's
     // ok that we don't store inferred type info for them in summaries.
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   C.positional([x = 1]);
   C.named({x: 1});
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.positional([dynamic x = 1]);
+  C.named({dynamic x: 1});
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  C.positional([dynamic x = 1]);
+  C.named({dynamic x: 1});
+}
+''');
+    }
   }
 
   test_parameterTypeNotInferred_initializingFormal() {
     // Strong mode doesn't do type inference on initializing formals, so it's
     // ok that we don't store inferred type info for them in summaries.
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   var x;
   C.positional([this.x = 1]);
   C.named({this.x: 1});
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C.positional([dynamic this.x]);
+  C.named({dynamic this.x});
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  dynamic x;
+  C.positional([dynamic this.x]);
+  C.named({dynamic this.x});
+}
+''');
+    }
   }
 
   test_parameterTypeNotInferred_staticMethod() {
     // Strong mode doesn't do type inference on parameters of static methods,
     // so it's ok that we don't store inferred type info for them in summaries.
-    checkLibrary('''
+    var library = checkLibrary('''
 class C {
   static void positional([x = 1]) {}
   static void named({x: 1}) {}
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static void positional([dynamic x = 1]) {}
+  static void named({dynamic x: 1}) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static void positional([dynamic x = 1]) {}
+  static void named({dynamic x: 1}) {}
+}
+''');
+    }
   }
 
   test_parameterTypeNotInferred_topLevelFunction() {
     // Strong mode doesn't do type inference on parameters of top level
     // functions, so it's ok that we don't store inferred type info for them in
     // summaries.
-    checkLibrary('''
+    var library = checkLibrary('''
 void positional([x = 1]) {}
 void named({x: 1}) {}
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void positional([dynamic x = 1]) {}
+void named({dynamic x: 1}) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void positional([dynamic x = 1]) {}
+void named({dynamic x: 1}) {}
+''');
+    }
   }
 
   test_parts() {
     addSource('/a.dart', 'part of my.lib;');
     addSource('/b.dart', 'part of my.lib;');
-    checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+    var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+--------------------
+unit: b.dart
+
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+--------------------
+unit: b.dart
+
+''');
+    }
   }
 
   test_parts_invalidUri() {
     allowMissingFiles = true;
     addSource('/foo/bar.dart', 'part of my.lib;');
-    checkLibrary('library my.lib; part "foo/";');
+    var library = checkLibrary('library my.lib; part "foo/";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+''');
+    }
   }
 
   test_parts_invalidUri_nullStringValue() {
     allowMissingFiles = true;
     addSource('/foo/bar.dart', 'part of my.lib;');
-    checkLibrary(r'''
+    var library = checkLibrary(r'''
 library my.lib;
 part "${foo}/bar.dart";
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+''');
+    }
   }
 
   test_propagated_type_refers_to_closure() {
-    checkLibrary('''
+    var library = checkLibrary('''
 void f() {
   var x = () => 0;
   var y = x;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void f() {}
+''');
+    }
   }
 
   test_setter_covariant() {
-    checkLibrary('class C { void set x(covariant int value); }');
+    var library = checkLibrary('class C { void set x(covariant int value); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(covariant int value);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  void set x(covariant int value);
+}
+''');
+    }
   }
 
   test_setter_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 void set x(value) {}''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+void set x(dynamic value) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+void set x(dynamic value) {}
+''');
+    }
   }
 
   test_setter_external() {
-    checkLibrary('external void set x(int value);');
+    var library = checkLibrary('external void set x(int value);');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+external void set x(int value) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+external void set x(int value) {}
+''');
+    }
   }
 
   test_setter_inferred_type_nonStatic_implicit_param() {
-    checkLibrary('class C extends D { void set f(value) {} }'
+    var library = checkLibrary('class C extends D { void set f(value) {} }'
         ' abstract class D { void set f(int value); }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void set f(int value) {}
+}
+abstract class D {
+  void set f(int value);
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C extends D {
+  void set f(dynamic value) {}
+}
+abstract class D {
+  void set f(int value);
+}
+''');
+    }
   }
 
   test_setter_inferred_type_static_implicit_return() {
-    checkLibrary('class C { static set f(int value) {} }');
+    var library = checkLibrary('class C { static set f(int value) {} }');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static void set f(int value) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+  static dynamic set f(int value) {}
+}
+''');
+    }
   }
 
   test_setter_inferred_type_top_level_implicit_return() {
-    checkLibrary('set f(int value) {}');
+    var library = checkLibrary('set f(int value) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void set f(int value) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic set f(int value) {}
+''');
+    }
   }
 
   test_setters() {
-    checkLibrary('void set x(int value) {} set y(value) {}');
+    var library = checkLibrary('void set x(int value) {} set y(value) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void set x(int value) {}
+void set y(dynamic value) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void set x(int value) {}
+dynamic set y(dynamic value) {}
+''');
+    }
   }
 
   test_syntheticFunctionType_genericClosure() {
@@ -4739,10 +12276,21 @@
       // and remove this hack.  See dartbug.com/25819
       return;
     }
-    checkLibrary('''
+    var library = checkLibrary('''
 final v = f() ? /*<T>*/(T t) => 0 : /*<T>*/(T t) => 1;
 bool f() => true;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+''');
+    }
   }
 
   test_syntheticFunctionType_genericClosure_inGenericFunction() {
@@ -4755,70 +12303,217 @@
       // and remove this hack.  See dartbug.com/25819
       return;
     }
-    checkLibrary('''
+    var library = checkLibrary('''
 void f<T, U>(bool b) {
   final v = b ? /*<V>*/(T t, U u, V v) => 0 : /*<V>*/(T t, U u, V v) => 1;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>(bool b) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+''');
+    }
   }
 
   test_syntheticFunctionType_inGenericClass() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T, U> {
   var v = f() ? (T t, U u) => 0 : (T t, U u) => 1;
 }
 bool f() => false;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+  synthetic C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+  dynamic v;
+}
+bool f() {}
+''');
+    }
   }
 
   test_syntheticFunctionType_inGenericFunction() {
-    checkLibrary('''
+    var library = checkLibrary('''
 void f<T, U>(bool b) {
   var v = b ? (T t, U u) => 0 : (T t, U u) => 1;
 }
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>(bool b) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+void f<T, U>(bool b) {}
+''');
+    }
   }
 
   test_syntheticFunctionType_noArguments() {
-    checkLibrary('''
+    var library = checkLibrary('''
 final v = f() ? () => 0 : () => 1;
 bool f() => true;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+final dynamic v;
+bool f() {}
+''');
+    }
   }
 
   test_syntheticFunctionType_withArguments() {
-    checkLibrary('''
+    var library = checkLibrary('''
 final v = f() ? (int x, String y) => 0 : (int x, String y) => 1;
 bool f() => true;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+final dynamic v;
+bool f() {}
+''');
+    }
   }
 
   test_type_arguments_explicit_dynamic_dynamic() {
-    checkLibrary('Map<dynamic, dynamic> m;');
+    var library = checkLibrary('Map<dynamic, dynamic> m;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+Map<dynamic, dynamic> m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+Map<dynamic, dynamic> m;
+''');
+    }
   }
 
   test_type_arguments_explicit_dynamic_int() {
-    checkLibrary('Map<dynamic, int> m;');
+    var library = checkLibrary('Map<dynamic, int> m;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+Map<dynamic, int> m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+Map<dynamic, int> m;
+''');
+    }
   }
 
   test_type_arguments_explicit_String_dynamic() {
-    checkLibrary('Map<String, dynamic> m;');
+    var library = checkLibrary('Map<String, dynamic> m;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+Map<String, dynamic> m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+Map<String, dynamic> m;
+''');
+    }
   }
 
   test_type_arguments_explicit_String_int() {
-    checkLibrary('Map<String, int> m;');
+    var library = checkLibrary('Map<String, int> m;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+Map<String, int> m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+Map<String, int> m;
+''');
+    }
   }
 
   test_type_arguments_implicit() {
-    checkLibrary('Map m;');
+    var library = checkLibrary('Map m;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+Map<dynamic, dynamic> m;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+Map<dynamic, dynamic> m;
+''');
+    }
   }
 
   test_type_dynamic() {
-    checkLibrary('dynamic d;');
+    var library = checkLibrary('dynamic d;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic d;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic d;
+''');
+    }
   }
 
   test_type_invalid_topLevelVariableElement_asType() {
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class C<T extends V> {}
 typedef V F(V p);
@@ -4827,218 +12522,1025 @@
 int V = 0;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(dynamic p);
+class C<T extends dynamic> {
+}
+dynamic V2;
+int V;
+dynamic f(dynamic p) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(dynamic p);
+class C<T extends dynamic> {
+}
+dynamic V2;
+int V;
+dynamic f(dynamic p) {}
+''');
+    }
   }
 
   test_type_invalid_topLevelVariableElement_asTypeArgument() {
-    checkLibrary(
+    var library = checkLibrary(
         '''
 var V;
 static List<V> V2;
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic V;
+List<dynamic> V2;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic V;
+List<dynamic> V2;
+''');
+    }
   }
 
   test_type_invalid_typeParameter_asPrefix() {
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class C<T> {
   m(T.K p) {}
 }
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  dynamic m(dynamic p) {}
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  dynamic m(dynamic p) {}
+}
+''');
+    }
   }
 
   test_type_reference_lib_to_lib() {
-    checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
+    var library =
+        checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_lib_to_part() {
     addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
-    checkLibrary('library l; part "a.dart"; C c; E e; F f;');
+    var library = checkLibrary('library l; part "a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+C c;
+E e;
+F f;
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+C c;
+E e;
+F f;
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+''');
+    }
   }
 
   test_type_reference_part_to_lib() {
     addSource('/a.dart', 'part of l; C c; E e; F f;');
-    checkLibrary(
+    var library = checkLibrary(
         'library l; part "a.dart"; class C {} enum E { v } typedef F();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+--------------------
+unit: a.dart
+
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+--------------------
+unit: a.dart
+
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_part_to_other_part() {
     addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
     addSource('/b.dart', 'part of l; C c; E e; F f;');
-    checkLibrary('library l; part "a.dart"; part "b.dart";');
+    var library = checkLibrary('library l; part "a.dart"; part "b.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+--------------------
+unit: b.dart
+
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+--------------------
+unit: b.dart
+
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_part_to_part() {
     addSource('/a.dart',
         'part of l; class C {} enum E { v } typedef F(); C c; E e; F f;');
-    checkLibrary('library l; part "a.dart";');
+    var library = checkLibrary('library l; part "a.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library l;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+typedef dynamic F();
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+class C {
+}
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_class() {
-    checkLibrary('class C {} C c;');
+    var library = checkLibrary('class C {} C c;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+C c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C {
+}
+C c;
+''');
+    }
   }
 
   test_type_reference_to_class_with_type_arguments() {
-    checkLibrary('class C<T, U> {} C<int, String> c;');
+    var library = checkLibrary('class C<T, U> {} C<int, String> c;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+C<int, String> c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+C<int, String> c;
+''');
+    }
   }
 
   test_type_reference_to_class_with_type_arguments_implicit() {
-    checkLibrary('class C<T, U> {} C c;');
+    var library = checkLibrary('class C<T, U> {} C c;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+C<dynamic, dynamic> c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T, U> {
+}
+C<dynamic, dynamic> c;
+''');
+    }
   }
 
   test_type_reference_to_enum() {
-    checkLibrary('enum E { v } E e;');
+    var library = checkLibrary('enum E { v } E e;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+E e;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+enum E {
+  final int index;
+  static const List<E> values;
+  static const E v;
+}
+E e;
+''');
+    }
   }
 
   test_type_reference_to_import() {
     addLibrarySource('/a.dart', 'class C {} enum E { v }; typedef F();');
-    checkLibrary('import "a.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_import_export() {
     addLibrarySource('/a.dart', 'export "b.dart";');
     addLibrarySource('/b.dart', 'class C {} enum E { v } typedef F();');
-    checkLibrary('import "a.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_import_export_export() {
     addLibrarySource('/a.dart', 'export "b.dart";');
     addLibrarySource('/b.dart', 'export "c.dart";');
     addLibrarySource('/c.dart', 'class C {} enum E { v } typedef F();');
-    checkLibrary('import "a.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_import_export_export_in_subdirs() {
     addLibrarySource('/a/a.dart', 'export "b/b.dart";');
     addLibrarySource('/a/b/b.dart', 'export "../c/c.dart";');
     addLibrarySource('/a/c/c.dart', 'class C {} enum E { v } typedef F();');
-    checkLibrary('import "a/a.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a/a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_import_export_in_subdirs() {
     addLibrarySource('/a/a.dart', 'export "b/b.dart";');
     addLibrarySource('/a/b/b.dart', 'class C {} enum E { v } typedef F();');
-    checkLibrary('import "a/a.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a/a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_import_part() {
     addLibrarySource('/a.dart', 'library l; part "b.dart";');
     addSource('/b.dart', 'part of l; class C {} enum E { v } typedef F();');
-    checkLibrary('import "a.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_import_part2() {
     addLibrarySource('/a.dart', 'library l; part "p1.dart"; part "p2.dart";');
     addSource('/p1.dart', 'part of l; class C1 {}');
     addSource('/p2.dart', 'part of l; class C2 {}');
-    checkLibrary('import "a.dart"; C1 c1; C2 c2;');
+    var library = checkLibrary('import "a.dart"; C1 c1; C2 c2;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C1 c1;
+C2 c2;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C1 c1;
+C2 c2;
+''');
+    }
   }
 
   test_type_reference_to_import_part_in_subdir() {
     addLibrarySource('/a/b.dart', 'library l; part "c.dart";');
     addSource('/a/c.dart', 'part of l; class C {} enum E { v } typedef F();');
-    checkLibrary('import "a/b.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a/b.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a/b.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a/b.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_import_relative() {
     addLibrarySource('/a.dart', 'class C {} enum E { v } typedef F();');
-    checkLibrary('import "a.dart"; C c; E e; F f;');
+    var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+    }
   }
 
   test_type_reference_to_typedef() {
-    checkLibrary('typedef F(); F f;');
+    var library = checkLibrary('typedef F(); F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+F f;
+''');
+    }
   }
 
   test_type_reference_to_typedef_with_type_arguments() {
-    checkLibrary('typedef U F<T, U>(T t); F<int, String> f;');
+    var library = checkLibrary('typedef U F<T, U>(T t); F<int, String> f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+    }
   }
 
   test_type_reference_to_typedef_with_type_arguments_implicit() {
-    checkLibrary('typedef U F<T, U>(T t); F f;');
+    var library = checkLibrary('typedef U F<T, U>(T t); F f;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+    }
   }
 
   test_type_unresolved() {
-    checkLibrary('C c;', allowErrors: true);
+    var library = checkLibrary('C c;', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic c;
+''');
+    }
   }
 
   test_type_unresolved_prefixed() {
-    checkLibrary('import "dart:core" as core; core.C c;', allowErrors: true);
+    var library = checkLibrary('import "dart:core" as core; core.C c;',
+        allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:core' as core;
+dynamic c;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:core' as core;
+dynamic c;
+''');
+    }
   }
 
   test_typedef_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 typedef F();''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+typedef dynamic F();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+typedef dynamic F();
+''');
+    }
   }
 
   test_typedef_parameter_parameters() {
-    checkLibrary('typedef F(g(x, y));');
+    var library = checkLibrary('typedef F(g(x, y));');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F((dynamic, dynamic) → dynamic g);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F((dynamic, dynamic) → dynamic g);
+''');
+    }
   }
 
   test_typedef_parameter_parameters_in_generic_class() {
-    checkLibrary('typedef F<A, B>(A g(B x));');
+    var library = checkLibrary('typedef F<A, B>(A g(B x));');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<A, B>((B) → A g);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<A, B>((B) → A g);
+''');
+    }
   }
 
   test_typedef_parameter_return_type() {
-    checkLibrary('typedef F(int g());');
+    var library = checkLibrary('typedef F(int g());');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(() → int g);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(() → int g);
+''');
+    }
   }
 
   test_typedef_parameter_type() {
-    checkLibrary('typedef F(int i);');
+    var library = checkLibrary('typedef F(int i);');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(int i);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(int i);
+''');
+    }
   }
 
   test_typedef_parameter_type_generic() {
-    checkLibrary('typedef F<T>(T t);');
+    var library = checkLibrary('typedef F<T>(T t);');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<T>(T t);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F<T>(T t);
+''');
+    }
   }
 
   test_typedef_parameters() {
-    checkLibrary('typedef F(x, y);');
+    var library = checkLibrary('typedef F(x, y);');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(dynamic x, dynamic y);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F(dynamic x, dynamic y);
+''');
+    }
   }
 
   test_typedef_return_type() {
-    checkLibrary('typedef int F();');
+    var library = checkLibrary('typedef int F();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef int F();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef int F();
+''');
+    }
   }
 
   test_typedef_return_type_generic() {
-    checkLibrary('typedef T F<T>();');
+    var library = checkLibrary('typedef T F<T>();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef T F<T>();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef T F<T>();
+''');
+    }
   }
 
   test_typedef_return_type_implicit() {
-    checkLibrary('typedef F();');
+    var library = checkLibrary('typedef F();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef dynamic F();
+''');
+    }
   }
 
   test_typedef_return_type_void() {
-    checkLibrary('typedef void F();');
+    var library = checkLibrary('typedef void F();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef void F();
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef void F();
+''');
+    }
   }
 
   test_typedef_type_parameters() {
-    checkLibrary('typedef U F<T, U>(T t);');
+    var library = checkLibrary('typedef U F<T, U>(T t);');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T, U>(T t);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T, U>(T t);
+''');
+    }
   }
 
   test_typedef_type_parameters_bound() {
-    checkLibrary('typedef U F<T extends Object, U extends D>(T t); class D {}');
+    var library = checkLibrary(
+        'typedef U F<T extends Object, U extends D>(T t); class D {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T extends Object, U extends D>(T t);
+class D {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T extends Object, U extends D>(T t);
+class D {
+}
+''');
+    }
   }
 
   test_typedef_type_parameters_f_bound_complex() {
-    checkLibrary('typedef U F<T extends List<U>, U>(T t);');
+    var library = checkLibrary('typedef U F<T extends List<U>, U>(T t);');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T extends List<U>, U>(T t);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T extends List<U>, U>(T t);
+''');
+    }
   }
 
   test_typedef_type_parameters_f_bound_simple() {
-    checkLibrary('typedef U F<T extends U, U>(T t);');
+    var library = checkLibrary('typedef U F<T extends U, U>(T t);');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T extends U, U>(T t);
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+typedef U F<T extends U, U>(T t);
+''');
+    }
   }
 
   test_typedefs() {
-    checkLibrary('f() {} g() {}');
+    var library = checkLibrary('f() {} g() {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+dynamic g() {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic f() {}
+dynamic g() {}
+''');
+    }
   }
 
   @failingTest
   test_unresolved_annotation_instanceCreation_argument_super() {
     // TODO(scheglov) fix https://github.com/dart-lang/sdk/issues/28553
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class A {
   const A(_);
@@ -5048,10 +13550,35 @@
 class C {}
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  A(_);
+}
+
+class C {
+  synthetic C();
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  A(_);
+}
+
+class C {
+  synthetic C();
+}
+''');
+    }
   }
 
   test_unresolved_annotation_instanceCreation_argument_this() {
-    checkLibrary(
+    var library = checkLibrary(
         '''
 class A {
   const A(_);
@@ -5061,59 +13588,294 @@
 class C {}
 ''',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A(dynamic _);
+}
+@A(this)
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class A {
+  const A(dynamic _);
+}
+@A(this)
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_namedConstructorCall_noClass() {
-    checkLibrary('@foo.bar() class C {}', allowErrors: true);
+    var library = checkLibrary('@foo.bar() class C {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@foo.bar()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@foo.bar()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_namedConstructorCall_noConstructor() {
-    checkLibrary('@String.foo() class C {}', allowErrors: true);
+    var library = checkLibrary('@String.foo() class C {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@String.foo()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@String.foo()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_prefixedIdentifier_badPrefix() {
-    checkLibrary('@foo.bar class C {}', allowErrors: true);
+    var library = checkLibrary('@foo.bar class C {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@foo.bar
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@foo.bar
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_prefixedIdentifier_noDeclaration() {
-    checkLibrary('import "dart:async" as foo; @foo.bar class C {}',
+    var library = checkLibrary(
+        'import "dart:async" as foo; @foo.bar class C {}',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.bar
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.bar
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_prefixedNamedConstructorCall_badPrefix() {
-    checkLibrary('@foo.bar.baz() class C {}', allowErrors: true);
+    var library = checkLibrary('@foo.bar.baz() class C {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@foo.bar.baz()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@foo.bar.baz()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_prefixedNamedConstructorCall_noClass() {
-    checkLibrary('import "dart:async" as foo; @foo.bar.baz() class C {}',
+    var library = checkLibrary(
+        'import "dart:async" as foo; @foo.bar.baz() class C {}',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.bar.baz()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.bar.baz()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_prefixedNamedConstructorCall_noConstructor() {
-    checkLibrary('import "dart:async" as foo; @foo.Future.bar() class C {}',
+    var library = checkLibrary(
+        'import "dart:async" as foo; @foo.Future.bar() class C {}',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.Future.bar()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.Future.bar()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_prefixedUnnamedConstructorCall_badPrefix() {
-    checkLibrary('@foo.bar() class C {}', allowErrors: true);
+    var library = checkLibrary('@foo.bar() class C {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@foo.bar()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@foo.bar()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_prefixedUnnamedConstructorCall_noClass() {
-    checkLibrary('import "dart:async" as foo; @foo.bar() class C {}',
+    var library = checkLibrary(
+        'import "dart:async" as foo; @foo.bar() class C {}',
         allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.bar()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'dart:async' as foo;
+@foo.bar()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_simpleIdentifier() {
-    checkLibrary('@foo class C {}', allowErrors: true);
+    var library = checkLibrary('@foo class C {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@foo
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@foo
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_annotation_unnamedConstructorCall_noClass() {
-    checkLibrary('@foo() class C {}', allowErrors: true);
+    var library = checkLibrary('@foo() class C {}', allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+@foo()
+class C {
+}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+@foo()
+class C {
+}
+''');
+    }
   }
 
   test_unresolved_export() {
     allowMissingFiles = true;
-    checkLibrary("export 'foo.dart';", allowErrors: true);
+    var library = checkLibrary("export 'foo.dart';", allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+export 'foo.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+export 'foo.dart';
+''');
+    }
   }
 
   test_unresolved_import() {
@@ -5124,101 +13886,452 @@
     expect(importedLibrary.loadLibraryFunction, isNotNull);
     expect(importedLibrary.publicNamespace, isNotNull);
     expect(importedLibrary.exportNamespace, isNotNull);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'foo.dart';
+''');
+    }
   }
 
   test_unresolved_part() {
     allowMissingFiles = true;
-    checkLibrary("part 'foo.dart';", allowErrors: true);
+    var library = checkLibrary("part 'foo.dart';", allowErrors: true);
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+part 'foo.dart';
+--------------------
+unit: foo.dart
+
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+part 'foo.dart';
+--------------------
+unit: foo.dart
+
+''');
+    }
   }
 
   test_unused_type_parameter() {
-    checkLibrary('''
+    var library = checkLibrary('''
 class C<T> {
   void f() {}
 }
 C<int> c;
 var v = c.f;
 ''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  void f() {}
+}
+C<int> c;
+() → void v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+class C<T> {
+  void f() {}
+}
+C<int> c;
+dynamic v;
+''');
+    }
   }
 
   test_variable_const() {
-    checkLibrary('const int i = 0;');
+    var library = checkLibrary('const int i = 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const int i = 0;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const int i = 0;
+''');
+    }
   }
 
   test_variable_documented() {
-    checkLibrary('''
+    var library = checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 var x;''');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+dynamic x;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+/**
+ * Docs
+ */
+dynamic x;
+''');
+    }
   }
 
   test_variable_final() {
-    checkLibrary('final int x = 0;');
+    var library = checkLibrary('final int x = 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+final int x;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+final int x;
+''');
+    }
   }
 
   test_variable_final_top_level_untyped() {
-    checkLibrary('final v = 0;');
+    var library = checkLibrary('final v = 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+final int v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+final dynamic v;
+''');
+    }
   }
 
   test_variable_getterInLib_setterInPart() {
     addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
-    checkLibrary('library my.lib; part "a.dart"; int get x => 42;');
+    var library =
+        checkLibrary('library my.lib; part "a.dart"; int get x => 42;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+int get x {}
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+int get x {}
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+''');
+    }
   }
 
   test_variable_getterInPart_setterInLib() {
     addSource('/a.dart', 'part of my.lib; int get x => 42;');
-    checkLibrary('library my.lib; part "a.dart"; void set x(int _) {}');
+    var library =
+        checkLibrary('library my.lib; part "a.dart"; void set x(int _) {}');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+void set x(int _) {}
+--------------------
+unit: a.dart
+
+int get x {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+void set x(int _) {}
+--------------------
+unit: a.dart
+
+int get x {}
+''');
+    }
   }
 
   test_variable_getterInPart_setterInPart() {
     addSource('/a.dart', 'part of my.lib; int get x => 42;');
     addSource('/b.dart', 'part of my.lib; void set x(int _) {}');
-    checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+    var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+int get x {}
+--------------------
+unit: b.dart
+
+void set x(int _) {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+int get x {}
+--------------------
+unit: b.dart
+
+void set x(int _) {}
+''');
+    }
   }
 
   test_variable_implicit_type() {
-    checkLibrary('var x;');
+    var library = checkLibrary('var x;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+dynamic x;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic x;
+''');
+    }
   }
 
   test_variable_inferred_type_implicit_initialized() {
-    checkLibrary('var v = 0;');
+    var library = checkLibrary('var v = 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+int v;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+dynamic v;
+''');
+    }
   }
 
   test_variable_propagatedType_const_noDep() {
-    checkLibrary('const i = 0;');
+    var library = checkLibrary('const i = 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+const int i = 0;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+const dynamic i = 0;
+''');
+    }
   }
 
   test_variable_propagatedType_final_dep_inLib() {
     addLibrarySource('/a.dart', 'final a = 1;');
-    checkLibrary('import "a.dart"; final b = a / 2;');
+    var library = checkLibrary('import "a.dart"; final b = a / 2;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+final num b;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'a.dart';
+final dynamic b;
+''');
+    }
   }
 
   test_variable_propagatedType_final_dep_inPart() {
     addSource('/a.dart', 'part of lib; final a = 1;');
-    checkLibrary('library lib; part "a.dart"; final b = a / 2;');
+    var library = checkLibrary('library lib; part "a.dart"; final b = a / 2;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library lib;
+part 'a.dart';
+final num b;
+--------------------
+unit: a.dart
+
+final int a;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library lib;
+part 'a.dart';
+final dynamic b;
+--------------------
+unit: a.dart
+
+final dynamic a;
+''');
+    }
   }
 
   test_variable_propagatedType_final_noDep() {
-    checkLibrary('final i = 0;');
+    var library = checkLibrary('final i = 0;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+final int i;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+final dynamic i;
+''');
+    }
   }
 
   test_variable_propagatedType_implicit_dep() {
     // The propagated type is defined in a library that is not imported.
     addLibrarySource('/a.dart', 'class C {}');
     addLibrarySource('/b.dart', 'import "a.dart"; C f() => null;');
-    checkLibrary('import "b.dart"; final x = f();');
+    var library = checkLibrary('import "b.dart"; final x = f();');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+import 'b.dart';
+final C x;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+import 'b.dart';
+final dynamic x;
+''');
+    }
   }
 
   test_variable_setterInPart_getterInPart() {
     addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
     addSource('/b.dart', 'part of my.lib; int get x => 42;');
-    checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+    var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+--------------------
+unit: b.dart
+
+int get x {}
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+--------------------
+unit: b.dart
+
+int get x {}
+''');
+    }
   }
 
   test_variables() {
-    checkLibrary('int i; int j;');
+    var library = checkLibrary('int i; int j;');
+    if (isStrongMode) {
+      checkElementText(
+          library,
+          r'''
+int i;
+int j;
+''');
+    } else {
+      checkElementText(
+          library,
+          r'''
+int i;
+int j;
+''');
+    }
   }
 
   /**
diff --git a/pkg/analyzer_cli/analyzer_cli.iml b/pkg/analyzer_cli/analyzer_cli.iml
index 4a27243..8eaae91 100644
--- a/pkg/analyzer_cli/analyzer_cli.iml
+++ b/pkg/analyzer_cli/analyzer_cli.iml
@@ -7,7 +7,18 @@
       <excludeFolder url="file://$MODULE_DIR$/bin/packages" />
       <excludeFolder url="file://$MODULE_DIR$/build" />
       <excludeFolder url="file://$MODULE_DIR$/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/bazel/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/bazel/proj/lib/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/bazel/proj/packages" />
       <excludeFolder url="file://$MODULE_DIR$/test/data/embedder_client/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/errors_reported_once/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/lib/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/flutter/lib/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/flutter/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/meta/lib/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/meta/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/data/flutter_analysis_options/somepkgs/packages" />
       <excludeFolder url="file://$MODULE_DIR$/test/data/library_and_parts/packages" />
       <excludeFolder url="file://$MODULE_DIR$/test/data/linter_project/packages" />
       <excludeFolder url="file://$MODULE_DIR$/test/data/no_lints_project/packages" />
diff --git a/pkg/front_end/front_end.iml b/pkg/front_end/front_end.iml
index 8b2c80f..7f7c017 100644
--- a/pkg/front_end/front_end.iml
+++ b/pkg/front_end/front_end.iml
@@ -2,7 +2,20 @@
 <module type="WEB_MODULE" version="4">
   <component name="NewModuleRootManager" inherit-compiler-output="true">
     <exclude-output />
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.pub" />
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+      <excludeFolder url="file://$MODULE_DIR$/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/fasta/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/fasta/parser/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/fasta/rasta/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/fasta/scanner/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/src/base/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/test/src/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/tool/fasta/packages" />
+      <excludeFolder url="file://$MODULE_DIR$/tool/packages" />
+    </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="Dart SDK" level="application" />
diff --git a/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart b/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart
index 5a74165..3933e7c 100644
--- a/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/dynamic_type_builder.dart
@@ -13,7 +13,9 @@
   DynamicTypeBuilder(this.type, LibraryBuilder compilationUnit, int charOffset)
       : super(null, 0, "dynamic", compilationUnit, charOffset);
 
-  R buildType(List<T> arguments) => type;
+  R buildType(LibraryBuilder library, List<T> arguments) => type;
 
-  R buildTypesWithBuiltArguments(List<R> arguments) => type;
+  R buildTypesWithBuiltArguments(LibraryBuilder library, List<R> arguments) {
+    return type;
+  }
 }
diff --git a/pkg/front_end/lib/src/fasta/builder/type_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_builder.dart
index 4a91321..8f0065e 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_builder.dart
@@ -4,7 +4,8 @@
 
 library fasta.type_builder;
 
-import 'builder.dart' show Builder, TypeDeclarationBuilder, TypeVariableBuilder;
+import 'builder.dart'
+    show Builder, LibraryBuilder, TypeDeclarationBuilder, TypeVariableBuilder;
 
 import 'scope.dart' show Scope;
 
@@ -27,5 +28,5 @@
 
   TypeBuilder subst(Map<TypeVariableBuilder, TypeBuilder> substitution) => this;
 
-  build();
+  build(LibraryBuilder library);
 }
diff --git a/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
index e0cc771..0053c44 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_declaration_builder.dart
@@ -5,7 +5,7 @@
 library fasta.type_declaration_builder;
 
 import 'builder.dart'
-    show Builder, MetadataBuilder, ModifierBuilder, TypeBuilder;
+    show Builder, LibraryBuilder, MetadataBuilder, ModifierBuilder, TypeBuilder;
 
 import '../util/relativize.dart' show relativizeUri;
 
@@ -32,8 +32,10 @@
 
   bool get isTypeDeclaration => true;
 
-  R buildType(List<T> arguments);
+  bool get isTypeVariable => false;
+
+  R buildType(LibraryBuilder library, List<T> arguments);
 
   /// [arguments] have already been built.
-  R buildTypesWithBuiltArguments(List<R> arguments);
+  R buildTypesWithBuiltArguments(LibraryBuilder library, List<R> arguments);
 }
diff --git a/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart b/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
index ee94d2c..a7b5df7 100644
--- a/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/type_variable_builder.dart
@@ -14,6 +14,8 @@
       String name, this.bound, LibraryBuilder compilationUnit, int charOffset)
       : super(null, null, name, compilationUnit, charOffset);
 
+  bool get isTypeVariable => true;
+
   String get debugName => "TypeVariableBuilder";
 
   StringBuffer printOn(StringBuffer buffer) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index e906a19..532feca 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -175,7 +175,7 @@
     } else if (node is BuilderAccessor) {
       return node.buildSimpleRead();
     } else if (node is TypeVariableBuilder) {
-      TypeParameterType type = node.buildTypesWithBuiltArguments(null);
+      TypeParameterType type = node.buildTypesWithBuiltArguments(library, null);
       if (!isInstanceContext && type.parameter.parent is Class) {
         return buildCompileTimeError(
             "Type variables can only be used in instance methods.");
@@ -183,9 +183,9 @@
         return new TypeLiteral(type);
       }
     } else if (node is TypeDeclarationBuilder) {
-      return new TypeLiteral(node.buildTypesWithBuiltArguments(null));
+      return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
     } else if (node is KernelTypeBuilder) {
-      return new TypeLiteral(node.build());
+      return new TypeLiteral(node.build(library));
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
@@ -949,8 +949,8 @@
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
-      push(wrapInvalid(
-          new TypeLiteral(accessor.buildTypesWithBuiltArguments(null))));
+      push(wrapInvalid(new TypeLiteral(
+          accessor.buildTypesWithBuiltArguments(library, null))));
     } else if (accessor is! BuilderAccessor) {
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
@@ -1148,7 +1148,7 @@
     if (identical(name, "dynamic")) return const DynamicType();
     Builder builder = scope.lookup(name, charOffset, uri);
     if (builder is TypeDeclarationBuilder) {
-      return builder.buildTypesWithBuiltArguments(arguments);
+      return builder.buildTypesWithBuiltArguments(library, arguments);
     }
     if (builder == null) {
       warning("Type not found: '$name'.", charOffset);
@@ -1202,11 +1202,11 @@
       warning("'${name.name}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
-      push(name.buildTypesWithBuiltArguments(arguments));
+      push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeDeclarationBuilder) {
-      push(name.buildTypesWithBuiltArguments(arguments));
+      push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeBuilder) {
-      push(name.build());
+      push(name.build(library));
     } else {
       push(toKernelType(name, arguments, beginToken.charOffset));
     }
@@ -1293,7 +1293,7 @@
           thisKeyword = null;
         }
       } else if (thisKeyword == null) {
-        variable = builder.build();
+        variable = builder.build(library);
         variable.initializer = name.initializer;
       } else if (builder.isField && builder.parent == classBuilder) {
         FieldBuilder field = builder;
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
index a6a7025..185e1d5 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart
@@ -62,7 +62,8 @@
   Class get target => cls;
 
   /// [arguments] have already been built.
-  InterfaceType buildTypesWithBuiltArguments(List<DartType> arguments) {
+  InterfaceType buildTypesWithBuiltArguments(
+      LibraryBuilder library, List<DartType> arguments) {
     return arguments == null
         ? cls.rawType
         : new InterfaceType(
@@ -72,27 +73,29 @@
             computeDefaultTypeArguments(cls.typeParameters, arguments));
   }
 
-  InterfaceType buildType(List<KernelTypeBuilder> arguments) {
+  InterfaceType buildType(
+      LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     List<DartType> typeArguments;
     if (arguments != null) {
       typeArguments = <DartType>[];
       for (KernelTypeBuilder builder in arguments) {
-        DartType type = builder.build();
+        DartType type = builder.build(library);
         if (type == null) {
           internalError("Bad type: ${builder.runtimeType}");
         }
         typeArguments.add(type);
       }
     }
-    return buildTypesWithBuiltArguments(typeArguments);
+    return buildTypesWithBuiltArguments(library, typeArguments);
   }
 
-  Supertype buildSupertype(List<KernelTypeBuilder> arguments) {
+  Supertype buildSupertype(
+      LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     List<DartType> typeArguments;
     if (arguments != null) {
       typeArguments = <DartType>[];
       for (KernelTypeBuilder builder in arguments) {
-        DartType type = builder.build();
+        DartType type = builder.build(library);
         if (type == null) {
           internalError("Bad type: ${builder.runtimeType}");
         }
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
index 1a36877..4261723 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart
@@ -174,7 +174,8 @@
 
   KernelTypeBuilder get mixedInType => null;
 
-  InterfaceType buildType(List<KernelTypeBuilder> arguments) {
+  InterfaceType buildType(
+      LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     return cls.rawType;
   }
 
@@ -183,10 +184,10 @@
       libraryBuilder.addCompileTimeError(
           -1, "An enum declaration can't be empty.");
     }
-    toStringMap.keyType = intType.build();
-    toStringMap.valueType = stringType.build();
+    toStringMap.keyType = intType.build(libraryBuilder);
+    toStringMap.valueType = stringType.build(libraryBuilder);
     KernelFieldBuilder indexFieldBuilder = members["index"];
-    Field indexField = indexFieldBuilder.build(libraryBuilder.library);
+    Field indexField = indexFieldBuilder.build(libraryBuilder);
     KernelProcedureBuilder toStringBuilder = members["toString"];
     toStringBuilder.body = new ReturnStatement(new MethodInvocation(
         toStringMap,
@@ -197,14 +198,14 @@
     List<Expression> values = <Expression>[];
     for (String name in constants) {
       KernelFieldBuilder builder = members[name];
-      values.add(new StaticGet(builder.build(libraryBuilder.library)));
+      values.add(new StaticGet(builder.build(libraryBuilder)));
     }
     KernelFieldBuilder valuesBuilder = members["values"];
-    valuesBuilder.build(libraryBuilder.library);
+    valuesBuilder.build(libraryBuilder);
     valuesBuilder.initializer =
         new ListLiteral(values, typeArgument: cls.rawType, isConst: true);
     KernelConstructorBuilder constructorBuilder = members[""];
-    Constructor constructor = constructorBuilder.build(libraryBuilder.library);
+    Constructor constructor = constructorBuilder.build(libraryBuilder);
     constructor.initializers.insert(
         0,
         new FieldInitializer(indexField,
@@ -213,7 +214,7 @@
     int index = 0;
     for (String constant in constants) {
       KernelFieldBuilder field = members[constant];
-      field.build(libraryBuilder.library);
+      field.build(libraryBuilder);
       Arguments arguments =
           new Arguments(<Expression>[new IntLiteral(index++)]);
       field.initializer =
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
index 2f0cfd2..8cb5a8d 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart
@@ -4,10 +4,15 @@
 
 library fasta.kernel_field_builder;
 
-import 'package:kernel/ast.dart' show Expression, Field, Library, Name;
+import 'package:kernel/ast.dart' show Expression, Field, Name;
 
 import 'kernel_builder.dart'
-    show Builder, FieldBuilder, KernelTypeBuilder, MetadataBuilder;
+    show
+        Builder,
+        FieldBuilder,
+        KernelTypeBuilder,
+        LibraryBuilder,
+        MetadataBuilder;
 
 class KernelFieldBuilder extends FieldBuilder<Expression> {
   final Field field;
@@ -24,10 +29,10 @@
     field.initializer = value..parent = field;
   }
 
-  Field build(Library library) {
-    field.name ??= new Name(name, library);
+  Field build(LibraryBuilder library) {
+    field.name ??= new Name(name, library.target);
     if (type != null) {
-      field.type = type.build();
+      field.type = type.build(library);
     }
     bool isInstanceMember = !isStatic && !isTopLevel;
     return field
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart
index aa671e9..09bd875 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart
@@ -11,6 +11,7 @@
         FormalParameterBuilder,
         KernelLibraryBuilder,
         KernelTypeBuilder,
+        LibraryBuilder,
         MetadataBuilder;
 
 class KernelFormalParameterBuilder
@@ -28,9 +29,9 @@
       : super(metadata, modifiers, type, name, hasThis, compilationUnit,
             charOffset);
 
-  VariableDeclaration build() {
+  VariableDeclaration build(LibraryBuilder library) {
     return declaration ??= new VariableDeclaration(name,
-        type: type?.build() ?? const DynamicType(),
+        type: type?.build(library) ?? const DynamicType(),
         isFinal: isFinal,
         isConst: isConst);
   }
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart
index 63e2010..70e0205 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_function_type_alias_builder.dart
@@ -46,7 +46,7 @@
       : super(metadata, returnType, name, typeVariables, formals, parent,
             charOffset);
 
-  DartType buildThisType() {
+  DartType buildThisType(LibraryBuilder library) {
     if (thisType != null) {
       if (thisType == const InvalidType()) {
         thisType = const DynamicType();
@@ -57,13 +57,14 @@
       return thisType;
     }
     thisType = const InvalidType();
-    DartType returnType = this.returnType?.build() ?? const DynamicType();
+    DartType returnType =
+        this.returnType?.build(library) ?? const DynamicType();
     List<DartType> positionalParameters = <DartType>[];
     List<NamedType> namedParameters;
     int requiredParameterCount = 0;
     if (formals != null) {
       for (KernelFormalParameterBuilder formal in formals) {
-        DartType type = formal.type?.build() ?? const DynamicType();
+        DartType type = formal.type?.build(library) ?? const DynamicType();
         if (formal.isPositional) {
           positionalParameters.add(type);
           if (formal.isRequired) requiredParameterCount++;
@@ -90,8 +91,9 @@
   }
 
   /// [arguments] have already been built.
-  DartType buildTypesWithBuiltArguments(List<DartType> arguments) {
-    var thisType = buildThisType();
+  DartType buildTypesWithBuiltArguments(
+      LibraryBuilder library, List<DartType> arguments) {
+    var thisType = buildThisType(library);
     if (thisType is DynamicType) return thisType;
     FunctionType result = thisType;
     if (result.typeParameters.isEmpty && arguments == null) return result;
@@ -103,8 +105,9 @@
     return substitute(result.withoutTypeParameters, substitution);
   }
 
-  DartType buildType(List<KernelTypeBuilder> arguments) {
-    var thisType = buildThisType();
+  DartType buildType(
+      LibraryBuilder library, List<KernelTypeBuilder> arguments) {
+    var thisType = buildThisType(library);
     if (thisType is DynamicType) return thisType;
     FunctionType result = thisType;
     if (result.typeParameters.isEmpty && arguments == null) return result;
@@ -112,9 +115,9 @@
     List<DartType> builtArguments = <DartType>[];
     if (arguments != null) {
       for (int i = 0; i < arguments.length; i++) {
-        builtArguments.add(arguments[i].build());
+        builtArguments.add(arguments[i].build(library));
       }
     }
-    return buildTypesWithBuiltArguments(builtArguments);
+    return buildTypesWithBuiltArguments(library, builtArguments);
   }
 }
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart
index da0f433..b2c215b 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_invalid_type_builder.dart
@@ -8,21 +8,24 @@
 
 import '../messages.dart' show warning;
 
-import 'kernel_builder.dart' show InvalidTypeBuilder, KernelTypeBuilder;
+import 'kernel_builder.dart'
+    show InvalidTypeBuilder, KernelTypeBuilder, LibraryBuilder;
 
 class KernelInvalidTypeBuilder
     extends InvalidTypeBuilder<KernelTypeBuilder, DartType> {
   KernelInvalidTypeBuilder(String name, int charOffset, Uri fileUri)
       : super(name, null, charOffset, fileUri);
 
-  DartType buildType(List<KernelTypeBuilder> arguments) {
+  DartType buildType(
+      LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     // TODO(ahe): Implement error handling.
     warning(fileUri, charOffset, "No type for: '$name'.");
     return const DynamicType();
   }
 
   /// [Arguments] have already been built.
-  DartType buildTypesWithBuiltArguments(List<DartType> arguments) {
+  DartType buildTypesWithBuiltArguments(
+      LibraryBuilder library, List<DartType> arguments) {
     // TODO(ahe): Implement error handling.
     warning(fileUri, charOffset, "No type for: '$name'.");
     return const DynamicType();
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
index fae44fc..c2d6b22 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart
@@ -68,6 +68,8 @@
       : library = new Library(uri, fileUri: relativizeUri(fileUri)),
         super(loader, fileUri);
 
+  Library get target => library;
+
   Uri get uri => library.importUri;
 
   KernelTypeBuilder addNamedType(
@@ -280,9 +282,9 @@
       Class cls = builder.build(this);
       library.addClass(cls);
     } else if (builder is KernelFieldBuilder) {
-      library.addMember(builder.build(library)..isStatic = true);
+      library.addMember(builder.build(this)..isStatic = true);
     } else if (builder is KernelProcedureBuilder) {
-      library.addMember(builder.build(library)..isStatic = true);
+      library.addMember(builder.build(this)..isStatic = true);
     } else if (builder is FunctionTypeAliasBuilder) {
       // Kernel discard typedefs and use their corresponding function types
       // directly.
@@ -394,7 +396,7 @@
   int finishTypeVariables(ClassBuilder object) {
     int count = boundlessTypeVariables.length;
     for (KernelTypeVariableBuilder builder in boundlessTypeVariables) {
-      builder.finish(object);
+      builder.finish(this, object);
     }
     boundlessTypeVariables.clear();
     return count;
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart
index c79e55f..8b9d903 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_mixin_application_builder.dart
@@ -16,6 +16,7 @@
         KernelNamedTypeBuilder,
         KernelTypeBuilder,
         KernelTypeVariableBuilder,
+        LibraryBuilder,
         MixinApplicationBuilder,
         TypeBuilder,
         TypeVariableBuilder;
@@ -45,15 +46,17 @@
         relativeFileUri = relativizeUri(fileUri),
         super(supertype, mixins, charOffset, fileUri);
 
-  InterfaceType build() => buildSupertype().asInterfaceType;
+  InterfaceType build(LibraryBuilder library) {
+    return buildSupertype(library)?.asInterfaceType;
+  }
 
-  Supertype buildSupertype() {
+  Supertype buildSupertype(LibraryBuilder library) {
     if (builtType != null) return builtType;
     KernelTypeBuilder s = this.supertype;
     for (KernelTypeBuilder builder in mixins) {
       s = applyMixin(s, builder);
     }
-    builtType = s.buildSupertype();
+    builtType = s.buildSupertype(library);
     return builtType;
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart
index f4f88ac..7dd7fb3 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_named_type_builder.dart
@@ -14,6 +14,7 @@
         KernelClassBuilder,
         KernelInvalidTypeBuilder,
         KernelTypeBuilder,
+        LibraryBuilder,
         NamedTypeBuilder,
         TypeBuilder,
         TypeVariableBuilder;
@@ -37,27 +38,35 @@
     return const DynamicType();
   }
 
-  Supertype handleMissingSuperType() {
+  Supertype handleMissingSupertype() {
     warning(fileUri, charOffset, "No type for: '$name'.");
     return null;
   }
 
-  DartType build() {
+  Supertype handleInvalidSupertype(LibraryBuilder library) {
+    String message = builder.isTypeVariable
+        ? "The type variable '$name' can't be used as supertype."
+        : "The type '$name' can't be used as supertype.";
+    library.addCompileTimeError(charOffset, message, fileUri);
+    return null;
+  }
+
+  DartType build(LibraryBuilder library) {
     if (name == "void") return const VoidType();
     if (name == "dynamic") return const DynamicType();
     if (builder == null) return handleMissingType();
-    return builder.buildType(arguments);
+    return builder.buildType(library, arguments);
   }
 
-  Supertype buildSupertype() {
+  Supertype buildSupertype(LibraryBuilder library) {
     if (name == "void") return null;
     if (name == "dynamic") return null;
-    if (builder == null) return handleMissingSuperType();
+    if (builder == null) return handleMissingSupertype();
     if (builder is KernelClassBuilder) {
       KernelClassBuilder builder = this.builder;
-      return builder.buildSupertype(arguments);
+      return builder.buildSupertype(library, arguments);
     } else {
-      return handleMissingSuperType();
+      return handleInvalidSupertype(library);
     }
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
index 08b6f47..cd8ee41 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart
@@ -16,7 +16,6 @@
         Expression,
         FunctionNode,
         Initializer,
-        Library,
         LocalInitializer,
         Member,
         Name,
@@ -52,6 +51,7 @@
         KernelLibraryBuilder,
         KernelTypeBuilder,
         KernelTypeVariableBuilder,
+        LibraryBuilder,
         MetadataBuilder,
         ProcedureBuilder,
         TypeVariableBuilder,
@@ -93,7 +93,7 @@
 
   bool get isNative => nativeMethodName != null;
 
-  FunctionNode buildFunction() {
+  FunctionNode buildFunction(LibraryBuilder library) {
     assert(function == null);
     FunctionNode result = new FunctionNode(body, asyncMarker: asyncModifier);
     if (typeVariables != null) {
@@ -104,7 +104,7 @@
     }
     if (formals != null) {
       for (KernelFormalParameterBuilder formal in formals) {
-        VariableDeclaration parameter = formal.build();
+        VariableDeclaration parameter = formal.build(library);
         if (formal.isNamed) {
           result.namedParameters.add(parameter);
         } else {
@@ -117,7 +117,7 @@
       }
     }
     if (returnType != null) {
-      result.returnType = returnType.build();
+      result.returnType = returnType.build(library);
     }
     if (!isConstructor && !isInstanceMember && parent is ClassBuilder) {
       List<TypeParameter> typeParameters = parent.target.typeParameters;
@@ -154,7 +154,7 @@
     return function = result;
   }
 
-  Member build(Library library);
+  Member build(LibraryBuilder library);
 
   void becomeNative(Loader loader) {
     target.isExternal = true;
@@ -220,16 +220,16 @@
     }
   }
 
-  Procedure build(Library library) {
+  Procedure build(LibraryBuilder library) {
     // TODO(ahe): I think we may call this twice on parts. Investigate.
     if (procedure.name == null) {
-      procedure.function = buildFunction();
+      procedure.function = buildFunction(library);
       procedure.function.parent = procedure;
       procedure.isAbstract = isAbstract;
       procedure.isStatic = isStatic;
       procedure.isExternal = isExternal;
       procedure.isConst = isConst;
-      procedure.name = new Name(name, library);
+      procedure.name = new Name(name, library.target);
     }
     return procedure;
   }
@@ -268,20 +268,20 @@
 
   ProcedureKind get kind => null;
 
-  Constructor build(Library library) {
+  Constructor build(LibraryBuilder library) {
     if (constructor.name == null) {
-      constructor.function = buildFunction();
+      constructor.function = buildFunction(library);
       constructor.function.parent = constructor;
       constructor.isConst = isConst;
       constructor.isExternal = isExternal;
-      constructor.name = new Name(name, library);
+      constructor.name = new Name(name, library.target);
     }
     return constructor;
   }
 
-  FunctionNode buildFunction() {
+  FunctionNode buildFunction(LibraryBuilder library) {
     // TODO(ahe): Should complain if another type is explicitly set.
-    return super.buildFunction()..returnType = const VoidType();
+    return super.buildFunction(library)..returnType = const VoidType();
   }
 
   Constructor get target => constructor;
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index 2ed1a8c..93ef761 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -132,9 +132,6 @@
       Builder builder = type.builder;
       if (builder is ClassBuilder) {
         set.add(builder);
-      } else if (builder is! InvalidTypeBuilder &&
-          builder is! DynamicTypeBuilder) {
-        internalError("Unhandled: ${builder.runtimeType}");
       }
     }
 
@@ -247,7 +244,7 @@
       loader.buildProgram();
       loader.checkSemantics();
       List<SourceClassBuilder> sourceClasses = collectAllSourceClasses();
-      installDefaultSupertypes(sourceClasses);
+      installDefaultSupertypes();
       installDefaultConstructors(sourceClasses);
       loader.resolveConstructors();
       loader.finishTypeVariables(objectClassBuilder);
@@ -353,17 +350,21 @@
     return null;
   }
 
-  void installDefaultSupertypes(List<SourceClassBuilder> builders) {
+  void installDefaultSupertypes() {
     Class objectClass = this.objectClass;
-    for (SourceClassBuilder builder in builders) {
-      Class cls = builder.target;
-      if (cls != objectClass) {
-        cls.supertype ??= objectClass.asRawSupertype;
-      }
-      if (builder.isMixinApplication) {
-        cls.mixedInType = builder.mixedInType.buildSupertype();
-      }
-    }
+    loader.builders.forEach((Uri uri, LibraryBuilder library) {
+      library.members.forEach((String name, Builder builder) {
+        if (builder is SourceClassBuilder) {
+          Class cls = builder.target;
+          if (cls != objectClass) {
+            cls.supertype ??= objectClass.asRawSupertype;
+          }
+          if (builder.isMixinApplication) {
+            cls.mixedInType = builder.mixedInType.buildSupertype(library);
+          }
+        }
+      });
+    });
     ticker.logMs("Installed Object as implicit superclass");
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart
index a1c3b70..9bee8f9 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_type_builder.dart
@@ -6,12 +6,12 @@
 
 import 'package:kernel/ast.dart' show DartType, Supertype;
 
-import 'kernel_builder.dart' show TypeBuilder;
+import 'kernel_builder.dart' show LibraryBuilder, TypeBuilder;
 
 abstract class KernelTypeBuilder extends TypeBuilder {
   KernelTypeBuilder(int charOffset, Uri fileUri) : super(charOffset, fileUri);
 
-  DartType build();
+  DartType build(LibraryBuilder library);
 
-  Supertype buildSupertype();
+  Supertype buildSupertype(LibraryBuilder library);
 }
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart
index 585bf1a..7475312 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_type_variable_builder.dart
@@ -15,6 +15,7 @@
         KernelLibraryBuilder,
         KernelNamedTypeBuilder,
         KernelTypeBuilder,
+        LibraryBuilder,
         TypeVariableBuilder;
 
 class KernelTypeVariableBuilder
@@ -27,7 +28,8 @@
       : parameter = new TypeParameter(name, null),
         super(name, bound, compilationUnit, charOffset);
 
-  DartType buildType(List<KernelTypeBuilder> arguments) {
+  DartType buildType(
+      LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     if (arguments != null) {
       return inputError(null, null,
           "Can't use type arguments with type parameter $parameter");
@@ -36,12 +38,13 @@
     }
   }
 
-  DartType buildTypesWithBuiltArguments(List<DartType> arguments) {
+  DartType buildTypesWithBuiltArguments(
+      LibraryBuilder library, List<DartType> arguments) {
     if (arguments != null) {
       return inputError(null, null,
           "Can't use type arguments with type parameter $parameter");
     } else {
-      return buildType(null);
+      return buildType(library, null);
     }
   }
 
@@ -49,7 +52,7 @@
     return new KernelNamedTypeBuilder(name, null, -1, null)..builder = this;
   }
 
-  void finish(KernelClassBuilder object) {
-    parameter.bound = bound?.build() ?? object.buildType(null);
+  void finish(LibraryBuilder library, KernelClassBuilder object) {
+    parameter.bound = bound?.build(library) ?? object.buildType(library, null);
   }
 }
diff --git a/pkg/front_end/lib/src/fasta/outline.dart b/pkg/front_end/lib/src/fasta/outline.dart
index 0604a26..1b14e2a 100644
--- a/pkg/front_end/lib/src/fasta/outline.dart
+++ b/pkg/front_end/lib/src/fasta/outline.dart
@@ -92,7 +92,8 @@
   }
 
   Future<KernelTarget> buildOutline([Uri output]) async {
-    TranslateUri uriTranslator = await TranslateUri.parse(c.options.sdk);
+    TranslateUri uriTranslator =
+        await TranslateUri.parse(c.options.sdk, c.options.packages);
     ticker.logMs("Read packages file");
     DillTarget dillTarget = new DillTarget(ticker, uriTranslator);
     KernelTarget kernelTarget = createKernelTarget(dillTarget, uriTranslator);
diff --git a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
index 3c2abf2..017534b 100644
--- a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
@@ -85,9 +85,9 @@
       if (builder is KernelFieldBuilder) {
         // TODO(ahe): It would be nice to have a common interface for the build
         // method to avoid duplicating these two cases.
-        cls.addMember(builder.build(library.library));
+        cls.addMember(builder.build(library));
       } else if (builder is KernelFunctionBuilder) {
-        cls.addMember(builder.build(library.library));
+        cls.addMember(builder.build(library));
       } else {
         internalError("Unhandled builder: ${builder.runtimeType}");
       }
@@ -99,14 +99,14 @@
         builder = builder.next;
       } while (builder != null);
     });
-    cls.supertype = supertype?.buildSupertype();
-    cls.mixedInType = mixedInType?.buildSupertype();
+    cls.supertype = supertype?.buildSupertype(library);
+    cls.mixedInType = mixedInType?.buildSupertype(library);
     // TODO(ahe): If `cls.supertype` is null, and this isn't Object, report a
     // compile-time error.
     cls.isAbstract = isAbstract;
     if (interfaces != null) {
       for (KernelTypeBuilder interface in interfaces) {
-        Supertype supertype = interface.buildSupertype();
+        Supertype supertype = interface.buildSupertype(library);
         if (supertype != null) {
           // TODO(ahe): Report an error if supertype is null.
           cls.implementedTypes.add(supertype);
diff --git a/pkg/front_end/test/fasta/compile.status b/pkg/front_end/test/fasta/compile.status
index 79faa18..7772214 100644
--- a/pkg/front_end/test/fasta/compile.status
+++ b/pkg/front_end/test/fasta/compile.status
@@ -7,9 +7,10 @@
 # pkg/fasta/lib/src/kernel/.
 
 await: Fail
-invocations: Fail
 function_type_recovery: Crash
+invocations: Fail
 statements: Fail # Make async tranformer optional for golden file testing.
+type_variable_as_super: Fail
 
 rasta/abstract_constructor: Fail
 rasta/bad_constructor_redirection: Fail
diff --git a/pkg/front_end/test/fasta/kompile.status b/pkg/front_end/test/fasta/kompile.status
index f0dc306..3442779 100644
--- a/pkg/front_end/test/fasta/kompile.status
+++ b/pkg/front_end/test/fasta/kompile.status
@@ -27,6 +27,7 @@
 statements: Crash
 super_rasta_copy: Crash
 top_level_accessors: Crash
+type_variable_as_super: Fail
 typedef: Crash
 
 rasta/abstract_constructor: Fail
diff --git a/runtime/bin/gen_snapshot.cc b/runtime/bin/gen_snapshot.cc
index 3a72a05..dfd09643 100644
--- a/runtime/bin/gen_snapshot.cc
+++ b/runtime/bin/gen_snapshot.cc
@@ -80,6 +80,7 @@
 static const char* assembly_filename = NULL;
 static const char* script_snapshot_filename = NULL;
 static bool dependencies_only = false;
+static bool print_dependencies = false;
 static const char* dependencies_filename = NULL;
 
 
@@ -331,6 +332,17 @@
   return false;
 }
 
+static bool ProcessPrintDependenciesOption(const char* option) {
+  const char* name = ProcessOption(option, "--print_dependencies");
+  if (name == NULL) {
+    name = ProcessOption(option, "--print-dependencies");
+  }
+  if (name != NULL) {
+    print_dependencies = true;
+    return true;
+  }
+  return false;
+}
 
 static bool ProcessEmbedderEntryPointsManifestOption(const char* option) {
   const char* name = ProcessOption(option, "--embedder_entry_points_manifest=");
@@ -406,6 +418,7 @@
         ProcessScriptSnapshotOption(argv[i]) ||
         ProcessDependenciesOption(argv[i]) ||
         ProcessDependenciesOnlyOption(argv[i]) ||
+        ProcessPrintDependenciesOption(argv[i]) ||
         ProcessEmbedderEntryPointsManifestOption(argv[i]) ||
         ProcessURLmappingOption(argv[i]) || ProcessPackageRootOption(argv[i]) ||
         ProcessPackagesOption(argv[i]) || ProcessEnvironmentOption(argv[i])) {
@@ -673,55 +686,72 @@
     return;
   }
 
-  ASSERT(dependencies_filename != NULL);
-  File* file = File::Open(dependencies_filename, File::kWriteTruncate);
-  if (file == NULL) {
-    Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
-                  dependencies_filename);
-    exit(kErrorExitCode);
-  }
+  ASSERT((dependencies_filename != NULL) || print_dependencies);
   bool success = true;
+  File* file = NULL;
+  if (dependencies_filename != NULL) {
+    file = File::Open(dependencies_filename, File::kWriteTruncate);
+    if (file == NULL) {
+      Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
+                    dependencies_filename);
+      exit(kErrorExitCode);
+    }
 
-  // Targets:
-  switch (snapshot_kind) {
-    case kCore:
-      success &= file->Print("%s ", vm_snapshot_data_filename);
-      success &= file->Print("%s ", isolate_snapshot_data_filename);
-      break;
-    case kScript:
-      success &= file->Print("%s ", script_snapshot_filename);
-      break;
-    case kAppAOTAssembly:
-      success &= file->Print("%s ", assembly_filename);
-      break;
-    case kAppAOTBlobs:
-      success &= file->Print("%s ", vm_snapshot_data_filename);
-      success &= file->Print("%s ", vm_snapshot_instructions_filename);
-      success &= file->Print("%s ", isolate_snapshot_data_filename);
-      success &= file->Print("%s ", isolate_snapshot_instructions_filename);
-      break;
+    // Targets:
+    switch (snapshot_kind) {
+      case kCore:
+        success &= file->Print("%s ", vm_snapshot_data_filename);
+        success &= file->Print("%s ", isolate_snapshot_data_filename);
+        break;
+      case kScript:
+        success &= file->Print("%s ", script_snapshot_filename);
+        break;
+      case kAppAOTAssembly:
+        success &= file->Print("%s ", assembly_filename);
+        break;
+      case kAppAOTBlobs:
+        success &= file->Print("%s ", vm_snapshot_data_filename);
+        success &= file->Print("%s ", vm_snapshot_instructions_filename);
+        success &= file->Print("%s ", isolate_snapshot_data_filename);
+        success &= file->Print("%s ", isolate_snapshot_instructions_filename);
+        break;
+    }
+
+    success &= file->Print(": ");
   }
 
-  success &= file->Print(": ");
-
   // Sources:
   if (snapshot_kind == kScript) {
-    success &= file->Print("%s ", vm_snapshot_data_filename);
-    success &= file->Print("%s ", isolate_snapshot_data_filename);
+    if (dependencies_filename != NULL) {
+      success &= file->Print("%s ", vm_snapshot_data_filename);
+      success &= file->Print("%s ", isolate_snapshot_data_filename);
+    }
+    if (print_dependencies) {
+      Log::Print("%s\n", vm_snapshot_data_filename);
+      Log::Print("%s\n", isolate_snapshot_data_filename);
+    }
   }
   for (intptr_t i = 0; i < dependencies->length(); i++) {
     char* dep = dependencies->At(i);
-    success &= file->Print("%s ", dep);
+    if (dependencies_filename != NULL) {
+      success &= file->Print("%s ", dep);
+    }
+    if (print_dependencies) {
+      Log::Print("%s\n", dep);
+    }
     free(dep);
   }
-  success &= file->Print("\n");
 
-  if (!success) {
-    Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
-                  dependencies_filename);
-    exit(kErrorExitCode);
+  if (dependencies_filename != NULL) {
+    success &= file->Print("\n");
+
+    if (!success) {
+      Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
+                    dependencies_filename);
+      exit(kErrorExitCode);
+    }
+    file->Release();
   }
-  file->Release();
   delete dependencies;
   isolate_data->set_dependencies(NULL);
 }
@@ -839,6 +869,7 @@
 "   --dependencies=<output-file>  Generates a Makefile with snapshot output  \n"
 "                                 files as targets and all transitive imports\n"
 "                                 as sources.                                \n"
+"   --print_dependencies          Prints all transitive imports to stdout.   \n"
 "   --dependencies_only           Don't create and output the snapshot.      \n"
 "                                                                            \n"
 " To create a core snapshot:                                                 \n"
@@ -1565,7 +1596,7 @@
     const bool is_kernel_file =
         TryReadKernel(app_script_name, &kernel, &kernel_length);
 
-    if (dependencies_filename != NULL) {
+    if ((dependencies_filename != NULL) || print_dependencies) {
       isolate_data->set_dependencies(new MallocGrowableArray<char*>());
     }
 
diff --git a/runtime/include/dart_api.h b/runtime/include/dart_api.h
index 0bbb63b..918e3cc 100644
--- a/runtime/include/dart_api.h
+++ b/runtime/include/dart_api.h
@@ -620,6 +620,7 @@
   bool enable_error_on_bad_type;
   bool enable_error_on_bad_override;
   bool use_field_guards;
+  bool use_osr;
 } Dart_IsolateFlags;
 
 /**
diff --git a/runtime/observatory/lib/src/elements/isolate_view.dart b/runtime/observatory/lib/src/elements/isolate_view.dart
index 7e7599e..8c0f186 100644
--- a/runtime/observatory/lib/src/elements/isolate_view.dart
+++ b/runtime/observatory/lib/src/elements/isolate_view.dart
@@ -389,6 +389,8 @@
                     ..children = [
                       new SpanElement()
                         ..children = [
+                          // TODO(bkonyi): zones will always be empty. See
+                          // issue #28885.
                           new SpanElement()
                             ..text = 'zone ${index++} ',
                           new CurlyBlockElement(queue: _r.queue)
diff --git a/runtime/observatory/lib/src/service/object.dart b/runtime/observatory/lib/src/service/object.dart
index 1618aed..954f24e 100644
--- a/runtime/observatory/lib/src/service/object.dart
+++ b/runtime/observatory/lib/src/service/object.dart
@@ -3107,6 +3107,8 @@
   String _kindString;
   int get memoryHighWatermark => _memoryHighWatermark;
   int _memoryHighWatermark;
+
+  // TODO(bkonyi): zones will always be empty. See issue #28885.
   List<Zone> get zones => _zones;
   final List<Zone> _zones = new List<Zone>();
 
@@ -3114,7 +3116,6 @@
 
   void _update(Map map, bool mapIsRef) {
     String rawKind = map['kind'];
-    List<Map> zoneList = map['zones'];
 
     switch(rawKind) {
       case "kUnknownTask":
@@ -3146,13 +3147,6 @@
     }
 
     _memoryHighWatermark = int.parse(map['_memoryHighWatermark']);
-
-    zones.clear();
-    zoneList.forEach((zone) {
-      int capacity = zone['capacity'];
-      int used = zone['used'];
-      zones.add(new Zone(capacity, used));
-    });
   }
 }
 
diff --git a/runtime/vm/BUILD.gn b/runtime/vm/BUILD.gn
index 19ba41f..3d1c34a 100644
--- a/runtime/vm/BUILD.gn
+++ b/runtime/vm/BUILD.gn
@@ -369,7 +369,6 @@
   assert(defined(invoker.libraries), "Need libraries in $target_name")
 
   concatenation_target_names = []
-  concatenation_files = []
 
   # Concatenate vm library patches.
   foreach(library, invoker.libraries) {
@@ -381,7 +380,6 @@
       output = target_output
     }
     concatenation_target_names += [ ":concatenate_${name}_patch" ]
-    concatenation_files += [ target_output ]
   }
 
   # Build the patched sdk out of the concatenated patches and the special
@@ -397,57 +395,16 @@
 
     script = "../../tools/patch_sdk.py"
 
-    # We list all files which make up the sdk (modulo patches) and get them
-    # back as a GN list object.
-    shared_sdk_sources = exec_script("../../tools/list_dart_files.py",
-                                     [
-                                       "absolute",
-                                       rebase_path("../../sdk/lib"),
-                                     ],
-                                     "list lines")
-
-    front_end_sources = exec_script("../../tools/list_dart_files.py",
-                                    [
-                                      "absolute",
-                                      rebase_path("../../pkg/front_end"),
-                                    ],
-                                    "list lines")
-
-    kernel_sources = exec_script("../../tools/list_dart_files.py",
-                                 [
-                                   "absolute",
-                                   rebase_path("../../pkg/kernel"),
-                                 ],
-                                 "list lines")
-
     # We list the `patch_sdk.dart` tool here because the [script] (which is
     # implicitly an input) will call it.
     inputs = [
       "../../tools/patch_sdk.dart",
     ]
-
-    # Files below are not patches, they will not be in [concatenation_files]
-    # but the `patch_sdk.dart` script will copy them into the patched sdk.
-    inputs += [
-      "../bin/builtin.dart",
-      "../bin/vmservice/vmservice_io.dart",
-      "../bin/vmservice/loader.dart",
-      "../bin/vmservice/server.dart",
-    ]
-
-    # Add all the normal sdk sources.
-    inputs += shared_sdk_sources
-
-    # Add all the concatenated patch files.
-    inputs += concatenation_files
-
-    # Add some front-end dependencies
-    inputs += front_end_sources
-    inputs += kernel_sources
+    depfile = "$root_out_dir/patched_sdk.d"
 
     outputs = [
       # Instead of listing all outputs we list a single well-known one.
-      "${patched_sdk_dir}/lib/core/core.dart",
+      "${patched_sdk_dir}/platform.dill",
     ]
 
     args = [ "--quiet" ]
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 3bd1c6c..dc9e0fe 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -5033,7 +5033,7 @@
   intptr_t buffer_len = OS::StrNLen(features, PendingBytes());
   if ((buffer_len != expected_len) ||
       strncmp(features, expected_features, expected_len)) {
-    const intptr_t kMessageBufferSize = 256;
+    const intptr_t kMessageBufferSize = 1024;
     char message_buffer[kMessageBufferSize];
     char* actual_features =
         OS::StrNDup(features, buffer_len < 128 ? buffer_len : 128);
diff --git a/runtime/vm/code_generator.cc b/runtime/vm/code_generator.cc
index f549231..72e3aae 100644
--- a/runtime/vm/code_generator.cc
+++ b/runtime/vm/code_generator.cc
@@ -1668,7 +1668,7 @@
   }
 
   if ((stack_overflow_flags & Thread::kOsrRequest) != 0) {
-    ASSERT(FLAG_use_osr);
+    ASSERT(isolate->use_osr());
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     ASSERT(frame != NULL);
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 5a6a1b9..4c4a87d 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -669,15 +669,13 @@
 
   if (Snapshot::IncludesCode(kind)) {
     // Checked mode affects deopt ids.
-    const bool asserts =
-        (isolate != NULL) ? isolate->asserts() : FLAG_enable_asserts;
-    const bool type_checks =
-        (isolate != NULL) ? isolate->type_checks() : FLAG_enable_type_checks;
-    const bool field_guards =
-        (isolate != NULL) ? isolate->use_field_guards() : FLAG_use_field_guards;
-    buffer.AddString(asserts ? " asserts" : " no-asserts");
-    buffer.AddString(type_checks ? " type-checks" : " no-type-checks");
-    buffer.AddString(field_guards ? "field-guards" : "no-field-guards");
+#define ADD_FLAG(name, isolate_flag, flag)                                     \
+  do {                                                                         \
+    const bool name = (isolate != NULL) ? isolate->name() : flag;              \
+    buffer.AddString(name ? (" " #name) : (" no-" #name));                     \
+  } while (0);
+    ISOLATE_FLAG_LIST(ADD_FLAG);
+#undef ADD_FLAG
 
 // Generated code must match the host architecture and ABI.
 #if defined(TARGET_ARCH_ARM)
diff --git a/runtime/vm/debugger_api_impl_test.cc b/runtime/vm/debugger_api_impl_test.cc
index ee47df9..24a339a 100644
--- a/runtime/vm/debugger_api_impl_test.cc
+++ b/runtime/vm/debugger_api_impl_test.cc
@@ -465,8 +465,9 @@
   int saved_threshold = FLAG_optimization_counter_threshold;
   const int kLowThreshold = 100;
   const int kHighThreshold = 10000;
-  bool saved_osr = FLAG_use_osr;
-  FLAG_use_osr = false;
+  Isolate* isolate = Isolate::Current();
+  const bool saved_use_osr = isolate->use_osr();
+  isolate->set_use_osr(false);
 
   if (optimize) {
     // Warm up the code to make sure it gets optimized.  We ignore any
@@ -511,7 +512,7 @@
   }
 
   FLAG_optimization_counter_threshold = saved_threshold;
-  FLAG_use_osr = saved_osr;
+  isolate->set_use_osr(saved_use_osr);
 }
 
 
diff --git a/runtime/vm/flag_list.h b/runtime/vm/flag_list.h
index 5831114..be174f0 100644
--- a/runtime/vm/flag_list.h
+++ b/runtime/vm/flag_list.h
@@ -25,6 +25,12 @@
 #define USING_MULTICORE false
 #endif
 
+#if defined(DART_PRECOMPILER)
+#define USING_PRECOMPILER true
+#else
+#define USING_PRECOMPILER false
+#endif
+
 // List of all flags in the VM.
 // Flags can be one of three categories:
 // * P roduct flags: Can be set in any of the deployment modes, including in
@@ -162,7 +168,7 @@
     "Use class hierarchy analysis even if it can cause deoptimization.")       \
   P(use_field_guards, bool, !USING_DBC,                                        \
     "Use field guards and track field types")                                  \
-  C(use_osr, false, true, bool, true, "Use OSR")                               \
+  C(use_osr, false, !USING_PRECOMPILER, bool, !USING_PRECOMPILER, "Use OSR")   \
   P(verbose_gc, bool, false, "Enables verbose GC.")                            \
   P(verbose_gc_hdr, int, 40, "Print verbose GC header interval.")              \
   R(verify_after_gc, false, bool, false,                                       \
diff --git a/runtime/vm/flow_graph_compiler.cc b/runtime/vm/flow_graph_compiler.cc
index 1aa4347..4610cd6 100644
--- a/runtime/vm/flow_graph_compiler.cc
+++ b/runtime/vm/flow_graph_compiler.cc
@@ -333,7 +333,7 @@
 
 
 bool FlowGraphCompiler::CanOSRFunction() const {
-  return FLAG_use_osr & CanOptimizeFunction() && !is_optimizing();
+  return isolate()->use_osr() && CanOptimizeFunction() && !is_optimizing();
 }
 
 
diff --git a/runtime/vm/hash_map.h b/runtime/vm/hash_map.h
index c9eb941..ff47301 100644
--- a/runtime/vm/hash_map.h
+++ b/runtime/vm/hash_map.h
@@ -175,8 +175,8 @@
   if (array_index_ < map_.array_size_) {
     // If we're not in the middle of a list, find the next array slot.
     if (list_index_ == kNil) {
-      while (KeyValueTrait::ValueOf(map_.array_[array_index_].kv) == kNoValue &&
-             array_index_ < map_.array_size_) {
+      while ((array_index_ < map_.array_size_) &&
+             KeyValueTrait::ValueOf(map_.array_[array_index_].kv) == kNoValue) {
         array_index_++;
       }
       if (array_index_ < map_.array_size_) {
diff --git a/runtime/vm/intermediate_language_arm.cc b/runtime/vm/intermediate_language_arm.cc
index a327937..ea29a8a 100644
--- a/runtime/vm/intermediate_language_arm.cc
+++ b/runtime/vm/intermediate_language_arm.cc
@@ -2949,7 +2949,7 @@
       : instruction_(instruction) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
-    if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+    if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
       const Register value = instruction_->locs()->temp(0).reg();
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
@@ -2968,7 +2968,8 @@
         instruction_->token_pos(), instruction_->deopt_id(),
         kStackOverflowRuntimeEntry, 0, instruction_->locs());
 
-    if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+    if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+        instruction_->in_loop()) {
       // In unoptimized code, record loop stack checks as possible OSR entries.
       compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
                                      instruction_->deopt_id(),
@@ -2980,7 +2981,7 @@
   }
 
   Label* osr_entry_label() {
-    ASSERT(FLAG_use_osr);
+    ASSERT(Isolate::Current()->use_osr());
     return &osr_entry_label_;
   }
 
diff --git a/runtime/vm/intermediate_language_arm64.cc b/runtime/vm/intermediate_language_arm64.cc
index 0d78d48..1f2a9b2 100644
--- a/runtime/vm/intermediate_language_arm64.cc
+++ b/runtime/vm/intermediate_language_arm64.cc
@@ -2642,7 +2642,7 @@
       : instruction_(instruction) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
-    if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+    if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
       const Register value = instruction_->locs()->temp(0).reg();
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
@@ -2661,7 +2661,8 @@
         instruction_->token_pos(), instruction_->deopt_id(),
         kStackOverflowRuntimeEntry, 0, instruction_->locs());
 
-    if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+    if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+        instruction_->in_loop()) {
       // In unoptimized code, record loop stack checks as possible OSR entries.
       compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
                                      instruction_->deopt_id(),
@@ -2673,7 +2674,7 @@
   }
 
   Label* osr_entry_label() {
-    ASSERT(FLAG_use_osr);
+    ASSERT(Isolate::Current()->use_osr());
     return &osr_entry_label_;
   }
 
diff --git a/runtime/vm/intermediate_language_ia32.cc b/runtime/vm/intermediate_language_ia32.cc
index e19bbf1..1f4f419 100644
--- a/runtime/vm/intermediate_language_ia32.cc
+++ b/runtime/vm/intermediate_language_ia32.cc
@@ -2565,7 +2565,7 @@
       : instruction_(instruction) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
-    if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+    if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
       __ movl(Address(THR, Thread::stack_overflow_flags_offset()),
@@ -2583,7 +2583,8 @@
         instruction_->token_pos(), instruction_->deopt_id(),
         kStackOverflowRuntimeEntry, 0, instruction_->locs());
 
-    if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+    if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+        instruction_->in_loop()) {
       // In unoptimized code, record loop stack checks as possible OSR entries.
       compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
                                      instruction_->deopt_id(),
@@ -2595,7 +2596,7 @@
   }
 
   Label* osr_entry_label() {
-    ASSERT(FLAG_use_osr);
+    ASSERT(Isolate::Current()->use_osr());
     return &osr_entry_label_;
   }
 
diff --git a/runtime/vm/intermediate_language_mips.cc b/runtime/vm/intermediate_language_mips.cc
index 36217a4..51882f8 100644
--- a/runtime/vm/intermediate_language_mips.cc
+++ b/runtime/vm/intermediate_language_mips.cc
@@ -2778,7 +2778,7 @@
       : instruction_(instruction) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
-    if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+    if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
       Register value = instruction_->locs()->temp(0).reg();
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
@@ -2797,7 +2797,8 @@
         instruction_->token_pos(), instruction_->deopt_id(),
         kStackOverflowRuntimeEntry, 0, instruction_->locs());
 
-    if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+    if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+        instruction_->in_loop()) {
       // In unoptimized code, record loop stack checks as possible OSR entries.
       compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
                                      instruction_->deopt_id(),
@@ -2809,7 +2810,7 @@
   }
 
   Label* osr_entry_label() {
-    ASSERT(FLAG_use_osr);
+    ASSERT(Isolate::Current()->use_osr());
     return &osr_entry_label_;
   }
 
diff --git a/runtime/vm/intermediate_language_x64.cc b/runtime/vm/intermediate_language_x64.cc
index 0193a09..c704319 100644
--- a/runtime/vm/intermediate_language_x64.cc
+++ b/runtime/vm/intermediate_language_x64.cc
@@ -2632,7 +2632,7 @@
       : instruction_(instruction) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
-    if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
+    if (compiler->isolate()->use_osr() && osr_entry_label()->IsLinked()) {
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
       __ movq(Address(THR, Thread::stack_overflow_flags_offset()),
@@ -2650,7 +2650,8 @@
         instruction_->token_pos(), instruction_->deopt_id(),
         kStackOverflowRuntimeEntry, 0, instruction_->locs());
 
-    if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
+    if (compiler->isolate()->use_osr() && !compiler->is_optimizing() &&
+        instruction_->in_loop()) {
       // In unoptimized code, record loop stack checks as possible OSR entries.
       compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
                                      instruction_->deopt_id(),
@@ -2663,7 +2664,7 @@
 
 
   Label* osr_entry_label() {
-    ASSERT(FLAG_use_osr);
+    ASSERT(Isolate::Current()->use_osr());
     return &osr_entry_label_;
   }
 
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index af870e9..b473061 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -722,31 +722,27 @@
 
 void Isolate::FlagsInitialize(Dart_IsolateFlags* api_flags) {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
-  api_flags->enable_type_checks = FLAG_enable_type_checks;
-  api_flags->enable_asserts = FLAG_enable_asserts;
-  api_flags->enable_error_on_bad_type = FLAG_error_on_bad_type;
-  api_flags->enable_error_on_bad_override = FLAG_error_on_bad_override;
-  api_flags->use_field_guards = FLAG_use_field_guards;
+#define INIT_FROM_FLAG(name, isolate_flag, flag) api_flags->isolate_flag = flag;
+  ISOLATE_FLAG_LIST(INIT_FROM_FLAG)
+#undef INIT_FROM_FLAG
 }
 
 
 void Isolate::FlagsCopyTo(Dart_IsolateFlags* api_flags) const {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
-  api_flags->enable_type_checks = type_checks();
-  api_flags->enable_asserts = asserts();
-  api_flags->enable_error_on_bad_type = error_on_bad_type();
-  api_flags->enable_error_on_bad_override = error_on_bad_override();
-  api_flags->use_field_guards = use_field_guards();
+#define INIT_FROM_FIELD(name, isolate_flag, flag)                              \
+  api_flags->isolate_flag = name();
+  ISOLATE_FLAG_LIST(INIT_FROM_FIELD)
+#undef INIT_FROM_FIELD
 }
 
 
 #if !defined(PRODUCT)
 void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
-  type_checks_ = api_flags.enable_type_checks;
-  asserts_ = api_flags.enable_asserts;
-  error_on_bad_type_ = api_flags.enable_error_on_bad_type;
-  error_on_bad_override_ = api_flags.enable_error_on_bad_override;
-  use_field_guards_ = api_flags.use_field_guards;
+#define SET_FROM_FLAG(name, isolate_flag, flag)                                \
+  name##_ = api_flags.isolate_flag;
+  ISOLATE_FLAG_LIST(SET_FROM_FLAG)
+#undef SET_FROM_FLAG
   // Leave others at defaults.
 }
 #endif  // !defined(PRODUCT)
diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h
index 3d9bf2b..e5c55b4 100644
--- a/runtime/vm/isolate.h
+++ b/runtime/vm/isolate.h
@@ -129,6 +129,19 @@
 // Fixed cache for exception handler lookup.
 typedef FixedCache<intptr_t, ExceptionHandlerInfo, 16> HandlerInfoCache;
 
+// List of Isolate flags with corresponding members of Dart_IsolateFlags and
+// corresponding global command line flags.
+//
+//       V(name, Dart_IsolateFlags-member-name, command-line-flag-name)
+//
+#define ISOLATE_FLAG_LIST(V)                                                   \
+  V(type_checks, enable_type_checks, FLAG_enable_type_checks)                  \
+  V(asserts, enable_asserts, FLAG_enable_asserts)                              \
+  V(error_on_bad_type, enable_error_on_bad_type, FLAG_error_on_bad_type)       \
+  V(error_on_bad_override, enable_error_on_bad_override,                       \
+    FLAG_error_on_bad_override)                                                \
+  V(use_field_guards, use_field_guards, FLAG_use_field_guards)                 \
+  V(use_osr, use_osr, FLAG_use_osr)
 
 class Isolate : public BaseIsolate {
  public:
@@ -634,17 +647,17 @@
   void FlagsCopyFrom(const Dart_IsolateFlags& api_flags);
 
 #if defined(PRODUCT)
-  bool type_checks() const { return FLAG_enable_type_checks; }
-  bool asserts() const { return FLAG_enable_asserts; }
-  bool error_on_bad_type() const { return FLAG_error_on_bad_type; }
-  bool error_on_bad_override() const { return FLAG_error_on_bad_override; }
-  bool use_field_guards() const { return FLAG_use_field_guards; }
+#define DECLARE_GETTER(name, isolate_flag_name, flag_name)                     \
+  bool name() const { return flag_name; }
+  ISOLATE_FLAG_LIST(DECLARE_GETTER)
+#undef DECLARE_GETTER
+  void set_use_osr(bool use_osr) { ASSERT(!use_osr); }
 #else   // defined(PRODUCT)
-  bool type_checks() const { return type_checks_; }
-  bool asserts() const { return asserts_; }
-  bool error_on_bad_type() const { return error_on_bad_type_; }
-  bool error_on_bad_override() const { return error_on_bad_override_; }
-  bool use_field_guards() const { return use_field_guards_; }
+#define DECLARE_GETTER(name, isolate_flag_name, flag_name)                     \
+  bool name() const { return name##_; }
+  ISOLATE_FLAG_LIST(DECLARE_GETTER)
+#undef DECLARE_GETTER
+  void set_use_osr(bool use_osr) { use_osr_ = use_osr; }
 #endif  // defined(PRODUCT)
 
   static void KillAllIsolates(LibMsgId msg_id);
@@ -770,11 +783,9 @@
 
 // Isolate-specific flags.
 #if !defined(PRODUCT)
-  bool type_checks_;
-  bool asserts_;
-  bool error_on_bad_type_;
-  bool error_on_bad_override_;
-  bool use_field_guards_;
+#define DECLARE_FIELD(name, isolate_flag_name, flag_name) bool name##_;
+  ISOLATE_FLAG_LIST(DECLARE_FIELD)
+#undef DECLARE_FIELD
 #endif  // !defined(PRODUCT)
 
   // Timestamps of last operation via service.
diff --git a/runtime/vm/kernel_isolate.cc b/runtime/vm/kernel_isolate.cc
index d0a09f8..0b6e867 100644
--- a/runtime/vm/kernel_isolate.cc
+++ b/runtime/vm/kernel_isolate.cc
@@ -71,15 +71,14 @@
     // Note: these flags must match those passed to the VM during
     // the app-jit training run (see //utils/kernel-service/BUILD.gn).
     Dart_IsolateFlags api_flags;
-    api_flags.version = DART_FLAGS_CURRENT_VERSION;
+    Isolate::FlagsInitialize(&api_flags);
     api_flags.enable_type_checks = false;
     api_flags.enable_asserts = false;
     api_flags.enable_error_on_bad_type = false;
     api_flags.enable_error_on_bad_override = false;
-#if defined(DART_PRECOMPILER)
-    api_flags.use_field_guards = false;
-#else
+#if !defined(DART_PRECOMPILER)
     api_flags.use_field_guards = true;
+    api_flags.use_osr = true;
 #endif
 
     isolate = reinterpret_cast<Isolate*>(create_callback(
diff --git a/runtime/vm/thread.cc b/runtime/vm/thread.cc
index dc54d6a..31ecabe 100644
--- a/runtime/vm/thread.cc
+++ b/runtime/vm/thread.cc
@@ -230,15 +230,6 @@
                      OSThread::ThreadIdToIntPtr(os_thread()->trace_id()));
   jsobj.AddProperty("kind", TaskKindToCString(task_kind()));
   jsobj.AddPropertyF("_memoryHighWatermark", "%" Pu "", memory_high_watermark_);
-  Zone* zone = zone_;
-  {
-    JSONArray zone_info_array(&jsobj, "zones");
-    zone = zone_;
-    while (zone != NULL) {
-      zone_info_array.AddValue(zone);
-      zone = zone->previous();
-    }
-  }
 }
 #endif
 
diff --git a/runtime/vm/thread_test.cc b/runtime/vm/thread_test.cc
index 74a97fd..7905969 100644
--- a/runtime/vm/thread_test.cc
+++ b/runtime/vm/thread_test.cc
@@ -325,24 +325,9 @@
   // Confirm all expected entries are in the JSON output.
   for (intptr_t i = 0; i < kTaskCount + 1; i++) {
     Thread* thread = threads[i];
-    Zone* top_zone = thread->zone();
-
     StackZone stack_zone(current_thread);
     Zone* current_zone = current_thread->zone();
 
-    // Check that all zones are present with correct sizes.
-    while (top_zone != NULL) {
-      char* zone_info_buf =
-          OS::SCreate(current_zone,
-                      "\"type\":\"_Zone\","
-                      "\"capacity\":%" Pd
-                      ","
-                      "\"used\":%" Pd "",
-                      top_zone->CapacityInBytes(), top_zone->SizeInBytes());
-      EXPECT_SUBSTRING(zone_info_buf, json);
-      top_zone = top_zone->previous();
-    }
-
     // Check the thread exists and is the correct size.
     char* thread_info_buf =
         OS::SCreate(current_zone,
diff --git a/runtime/vm/zone.cc b/runtime/vm/zone.cc
index fc988a7..8b3cdac 100644
--- a/runtime/vm/zone.cc
+++ b/runtime/vm/zone.cc
@@ -301,6 +301,7 @@
 
 
 #ifndef PRODUCT
+// TODO(bkonyi): Currently dead code. See issue #28885.
 void Zone::PrintJSON(JSONStream* stream) const {
   JSONObject jsobj(stream);
   intptr_t capacity = CapacityInBytes();
diff --git a/tests/co19/co19-kernel.status b/tests/co19/co19-kernel.status
index c7dda2b..51f15c2 100644
--- a/tests/co19/co19-kernel.status
+++ b/tests/co19/co19-kernel.status
@@ -101,19 +101,11 @@
 Language/Classes/Superclasses/Inheritance_and_Overriding/inheritance_t03: RuntimeError
 Language/Classes/Superclasses/superclass_of_itself_t01: MissingCompileTimeError
 Language/Classes/Superclasses/superclass_of_itself_t02: MissingCompileTimeError
-Language/Classes/Superclasses/wrong_superclass_t01: MissingCompileTimeError
-Language/Classes/Superclasses/wrong_superclass_t02: DartkCrash
-Language/Classes/Superclasses/wrong_superclass_t03: MissingCompileTimeError
-Language/Classes/Superclasses/wrong_superclass_t05: DartkCrash
 Language/Classes/Superclasses/wrong_superclass_t07: Crash
 Language/Classes/Superclasses/wrong_superclass_t08: MissingCompileTimeError
 Language/Classes/Superinterfaces/dynamic_type_t01: MissingCompileTimeError
 Language/Classes/Superinterfaces/dynamic_type_t02: MissingCompileTimeError
 Language/Classes/Superinterfaces/itself_t01: MissingCompileTimeError
-Language/Classes/Superinterfaces/type_variable_as_superinterface_t01: DartkCrash
-Language/Classes/Superinterfaces/wrong_type_t01: MissingCompileTimeError
-Language/Classes/Superinterfaces/wrong_type_t02: DartkCrash
-Language/Classes/Superinterfaces/wrong_type_t03: MissingCompileTimeError
 Language/Classes/Superinterfaces/wrong_type_t04: MissingCompileTimeError
 Language/Classes/Superinterfaces/wrong_type_t05: MissingCompileTimeError
 Language/Classes/declarations_t02: MissingCompileTimeError
@@ -308,7 +300,6 @@
 Language/Expressions/Method_Invocation/Super_Invocation/invocation_t03: MissingCompileTimeError
 Language/Expressions/Method_Invocation/Super_Invocation/syntax_t02: DartkCrash
 Language/Expressions/Method_Invocation/Super_Invocation/syntax_t03: DartkCrash
-Language/Expressions/Numbers/extend_or_implement_double_t06: MissingCompileTimeError
 Language/Expressions/Numbers/syntax_t21: MissingCompileTimeError
 Language/Expressions/Numbers/syntax_t25: MissingCompileTimeError
 Language/Expressions/Numbers/syntax_t26: MissingCompileTimeError
@@ -393,11 +384,9 @@
 Language/Libraries_and_Scripts/Imports/namespace_changes_t27: CompileTimeError
 Language/Libraries_and_Scripts/Imports/same_name_t02/01: MissingRuntimeError
 Language/Libraries_and_Scripts/Imports/same_name_t05: RuntimeError
-Language/Libraries_and_Scripts/Imports/same_name_t07: MissingCompileTimeError
 Language/Libraries_and_Scripts/Imports/same_name_t10: RuntimeError
 Language/Libraries_and_Scripts/Imports/same_name_t12/01: MissingRuntimeError
 Language/Libraries_and_Scripts/Imports/same_name_t15/01: MissingRuntimeError
-Language/Libraries_and_Scripts/Imports/same_name_t17: MissingCompileTimeError
 Language/Libraries_and_Scripts/Imports/same_name_t19: RuntimeError
 Language/Libraries_and_Scripts/Imports/static_type_t01: Skip # No support for deferred libraries.
 Language/Libraries_and_Scripts/Imports/syntax_t32: MissingCompileTimeError
@@ -449,15 +438,11 @@
 Language/Mixins/Mixin_Application/syntax_t15: MissingCompileTimeError
 Language/Mixins/Mixin_Application/wrong_mixin_type_t01: MissingCompileTimeError
 Language/Mixins/Mixin_Application/wrong_mixin_type_t02: MissingCompileTimeError
-Language/Mixins/Mixin_Application/wrong_mixin_type_t03: MissingCompileTimeError
-Language/Mixins/Mixin_Application/wrong_mixin_type_t04: MissingCompileTimeError
 Language/Mixins/Mixin_Application/wrong_mixin_type_t05: DartkCrash
 Language/Mixins/Mixin_Application/wrong_mixin_type_t06: DartkCrash
 Language/Mixins/Mixin_Application/wrong_mixin_type_t07: MissingCompileTimeError
-Language/Mixins/Mixin_Application/wrong_mixin_type_t08: Crash
 Language/Mixins/Mixin_Application/wrong_type_t01: MissingCompileTimeError
 Language/Mixins/Mixin_Application/wrong_type_t02: DartkCrash
-Language/Mixins/Mixin_Application/wrong_type_t03: MissingCompileTimeError
 Language/Mixins/Mixin_Application/wrong_type_t04: Crash
 Language/Mixins/Mixin_Application/wrong_type_t05: MissingCompileTimeError
 Language/Mixins/Mixin_Application/wrong_type_t06: Crash
@@ -706,6 +691,7 @@
 Language/Overview/Scoping/conflicting_names_t43: Crash
 Language/Overview/Scoping/hiding_declaration_t11: Crash
 Language/Overview/Scoping/hiding_declaration_t12: Crash
+LibTest/isolate/Isolate/spawnUri_A01_t04: Pass, Slow, Timeout
 
 # dartk: precompilation failures
 [ $compiler == dartkp ]
@@ -749,6 +735,7 @@
 Language/Expressions/Function_Invocation/Unqualified_Invocation/prefix_object_invocation_t01: MissingCompileTimeError
 Language/Expressions/Identifier_Reference/evaluation_prefix_t01: MissingCompileTimeError
 Language/Expressions/Identifier_Reference/evaluation_type_parameter_t02: MissingCompileTimeError
+Language/Expressions/Instance_Creation/New/syntax_t02: MissingCompileTimeError
 Language/Expressions/Logical_Boolean_Expressions/syntax_t02: MissingCompileTimeError
 Language/Expressions/Logical_Boolean_Expressions/syntax_t03: MissingCompileTimeError
 Language/Expressions/Method_Invocation/Super_Invocation/invocation_t01: MissingCompileTimeError
@@ -766,6 +753,8 @@
 Language/Expressions/This/placement_t06: MissingCompileTimeError
 Language/Expressions/This/placement_t07: MissingCompileTimeError
 Language/Expressions/This/placement_t08: MissingCompileTimeError
+Language/Libraries_and_Scripts/Imports/namespace_changes_t07: MissingCompileTimeError
+Language/Libraries_and_Scripts/Imports/namespace_changes_t08: MissingCompileTimeError
 Language/Overview/Privacy/private_and_public_t04: RuntimeError
 Language/Overview/Scoping/conflicting_names_t43: Crash
 Language/Overview/Scoping/hiding_declaration_t11: Crash
diff --git a/tests/language/language_kernel.status b/tests/language/language_kernel.status
index 4d58159..c98b85d 100644
--- a/tests/language/language_kernel.status
+++ b/tests/language/language_kernel.status
@@ -323,8 +323,6 @@
 export_double_same_main_test: Crash
 export_main_test: Crash
 export_private_test/01: MissingCompileTimeError
-extend_type_parameter2_negative_test: DartkCrash
-extend_type_parameter_negative_test: DartkCrash
 external_test/11: MissingCompileTimeError
 external_test/12: MissingCompileTimeError
 external_test/13: MissingRuntimeError
@@ -379,7 +377,6 @@
 function_type_alias5_test/02: MissingCompileTimeError
 function_type_alias6_test/00: MissingCompileTimeError
 function_type_alias7_test/00: MissingCompileTimeError
-function_type_alias7_test/01: DartkCrash
 function_type_alias7_test/02: MissingCompileTimeError
 function_type_alias9_test/00: MissingCompileTimeError
 function_type_parameter2_negative_test: Crash
@@ -413,7 +410,6 @@
 initializing_formal_final_test: RuntimeError
 inst_field_initializer1_negative_test: Fail
 instanceof3_test: RuntimeError
-interface2_negative_test: Fail
 interface_cycle_test/01: MissingCompileTimeError
 interface_cycle_test/02: MissingCompileTimeError
 invocation_mirror_test: RuntimeError
@@ -431,22 +427,14 @@
 large_class_declaration_test: SkipSlow  # KernelVM Issue 28312
 library_ambiguous_test/00: MissingRuntimeError
 library_ambiguous_test/04: MissingRuntimeError
-library_ambiguous_test/05: MissingCompileTimeError
 library_env_test/has_html_support: RuntimeError
 library_env_test/has_no_io_support: RuntimeError
 list_literal2_negative_test: Fail
 list_literal4_test: RuntimeError
 main_not_a_function_test/01: Crash
 malformed2_test/00: RuntimeError
-malformed_inheritance_test/01: MissingCompileTimeError
-malformed_inheritance_test/03: Crash
-malformed_inheritance_test/05: MissingCompileTimeError
-malformed_inheritance_test/07: DartkCrash
-malformed_inheritance_test/08: DartkCrash
 malformed_inheritance_test/09: MissingCompileTimeError
 malformed_inheritance_test/10: MissingCompileTimeError
-malformed_inheritance_test/11: DartkCrash
-malformed_inheritance_test/12: DartkCrash
 malformed_test/none: RuntimeError
 map_literal2_negative_test: Fail
 map_literal3_test: RuntimeError
@@ -487,11 +475,6 @@
 mixin_illegal_object_test/01: MissingCompileTimeError
 mixin_illegal_object_test/02: MissingCompileTimeError
 mixin_illegal_syntax_test/00: DartkCrash
-mixin_invalid_inheritance1_test/01: Crash
-mixin_invalid_inheritance1_test/02: Crash
-mixin_invalid_inheritance1_test/03: Crash
-mixin_invalid_inheritance2_test/01: MissingCompileTimeError
-mixin_invalid_inheritance2_test/02: MissingCompileTimeError
 mixin_invalid_inheritance2_test/03: DartkCrash
 mixin_issue10216_2_test: RuntimeError
 mixin_mixin2_test: RuntimeError
@@ -534,8 +517,6 @@
 on_catch_malformed_type_test: RuntimeError
 parameter_initializer6_negative_test: Fail
 part2_test: RuntimeError
-prefix13_negative_test: Fail
-prefix15_negative_test: Fail
 private_access_test/05: RuntimeError
 private_access_test/06: RuntimeError
 private_super_constructor_test/01: MissingCompileTimeError
@@ -656,7 +637,6 @@
 vm/debug_break_enabled_vm_test/none: CompileTimeError
 vm/regress_27201_test: CompileTimeError
 vm/regress_27671_test: RuntimeError
-vm/regress_28325_test: RuntimeError
 vm/type_cast_vm_test: RuntimeError
 vm/type_vm_test: RuntimeError
 
@@ -718,14 +698,13 @@
 super_call4_test: RuntimeError
 super_getter_setter_test: RuntimeError
 try_catch_syntax_test/05: MissingCompileTimeError
-vm/lazy_deopt_vm_test: Pass, Slow
-vm/lazy_deopt_vm_test: Pass, Timeout
+vm/lazy_deopt_vm_test: Pass, Slow, Timeout
 vm/optimized_stacktrace_test: Skip # Issue 28788
 
 # dartk: JIT failures (debug)
 [ $compiler == dartk && $mode == debug ]
 constructor_duplicate_initializers_test/03: Crash
-deopt_inlined_function_lazy_test: Timeout
+deopt_inlined_function_lazy_test: Skip
 hello_dart_test: Crash  # error: expected: cls.is_type_finalized()
 not_enough_positional_arguments_test/02: Crash  # Dartk Issue 28301
 not_enough_positional_arguments_test/05: Crash  # Dartk Issue 28301
@@ -739,6 +718,7 @@
 ref_before_declaration_test/07: Crash
 ref_before_declaration_test/none: Crash
 try_catch_syntax_test/05: Crash
+vm/lazy_deopt_vm_test: Crash
 
 # dartk: precompilation failures
 [ $compiler == dartkp ]
@@ -774,6 +754,8 @@
 illegal_initializer_test/04: MissingCompileTimeError
 illegal_invocation_test/01: MissingCompileTimeError
 label_test: RuntimeError
+named_constructor_test/05: MissingCompileTimeError
+named_constructor_test/08: MissingCompileTimeError
 prefix_assignment_test/01: MissingCompileTimeError
 prefix_assignment_test/02: MissingCompileTimeError
 prefix_identifier_reference_test/01: MissingCompileTimeError
diff --git a/tools/VERSION b/tools/VERSION
index a5691e7..00ca6a0 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 1
 MINOR 23
 PATCH 0
-PRERELEASE 3
+PRERELEASE 4
 PRERELEASE_PATCH 0
diff --git a/tools/deps/dartium.deps/DEPS.chromium b/tools/deps/dartium.deps/DEPS.chromium
index d15aff5..8d00973 100644
--- a/tools/deps/dartium.deps/DEPS.chromium
+++ b/tools/deps/dartium.deps/DEPS.chromium
@@ -623,17 +623,6 @@
   {
     'action': [
       'python',
-      'src/third_party/mojo/src/mojo/public/tools/download_shell_binary.py',
-      '--tools-directory=../../../../../../tools'
-    ],
-    'pattern':
-      '',
-    'name':
-      'download_mojo_shell'
-  },
-  {
-    'action': [
-      'python',
       'src/third_party/instrumented_libraries/scripts/download_binaries.py'
     ],
     'pattern':
diff --git a/tools/patch_sdk.dart b/tools/patch_sdk.dart
index 33a06fb..bcdc635 100644
--- a/tools/patch_sdk.dart
+++ b/tools/patch_sdk.dart
@@ -13,8 +13,41 @@
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:path/path.dart' as path;
-import 'package:front_end/src/fasta/compile_platform.dart' as
-    compile_platform;
+import 'package:front_end/src/fasta/compile_platform.dart' as compile_platform;
+
+import 'package:front_end/src/fasta/outline.dart' show CompileTask;
+
+import 'package:front_end/src/fasta/compiler_command_line.dart'
+    show CompilerCommandLine;
+
+import 'package:front_end/src/fasta/compiler_context.dart' show CompilerContext;
+
+import 'package:front_end/src/fasta/ticker.dart' show Ticker;
+
+/// Set of input files that were read by this script to generate patched SDK.
+/// We will dump it out into the depfile for ninja to use.
+///
+/// For more information see GN and Ninja references:
+///    https://chromium.googlesource.com/chromium/src/+/56807c6cb383140af0c03da8f6731d77785d7160/tools/gn/docs/reference.md#depfile_string_File-name-for-input-dependencies-for-actions
+///    https://ninja-build.org/manual.html#_depfile
+///
+final deps = new Set<String>();
+
+/// Create [File] object from the given path and register it as a dependency.
+File getInputFile(String path, {canBeMissing: false}) {
+  final file = new File(path);
+  if (!file.existsSync()) {
+    if (!canBeMissing) throw "patch_sdk.dart expects all inputs to exist";
+    return null;
+  }
+  deps.add(file.absolute.path);
+  return file;
+}
+
+/// Read the given file synchronously as a string and register this path as
+/// a dependency.
+String readInputFile(String path, {canBeMissing: false}) =>
+    getInputFile(path, canBeMissing: canBeMissing)?.readAsStringSync();
 
 Future main(List<String> argv) async {
   var base = path.fromUri(Platform.script);
@@ -28,8 +61,8 @@
     final sdkExample = path.relative(path.join(repositoryDir, 'sdk'));
     final patchExample = path.relative(
         path.join(repositoryDir, 'out', 'DebugX64', 'obj', 'gen', 'patch'));
-    final outExample = path.relative(path.join(repositoryDir, 'out', 'DebugX64',
-                                               'obj', 'gen', 'patched_sdk'));
+    final outExample = path.relative(path.join(
+        repositoryDir, 'out', 'DebugX64', 'obj', 'gen', 'patched_sdk'));
     print('For example:');
     print('\$ $self vm $sdkExample $patchExample $outExample');
 
@@ -37,6 +70,7 @@
   }
 
   var mode = argv[0];
+  assert(mode == "vm");
   var input = argv[1];
   var sdkLibIn = path.join(input, 'lib');
   var patchIn = argv[2];
@@ -48,12 +82,11 @@
   var INTERNAL_PATH = '_internal/compiler/js_lib/';
 
   // Copy and patch libraries.dart and version
-  var libContents = new File(path.join(sdkLibIn, '_internal',
-      'sdk_library_metadata', 'lib', 'libraries.dart')).readAsStringSync();
-  if (mode == 'vm') {
-    libContents = libContents.replaceAll(
-        ' libraries = const {',
-        ''' libraries = const {
+  var libContents = readInputFile(path.join(
+      sdkLibIn, '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart'));
+  libContents = libContents.replaceAll(
+      ' libraries = const {',
+      ''' libraries = const {
 
   "_builtin": const LibraryInfo(
       "_builtin/_builtin.dart",
@@ -80,39 +113,25 @@
       platforms: VM_PLATFORM),
 
 ''');
-  }
   _writeSync(
       path.join(
           sdkOut, '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart'),
       libContents);
-  if (mode == 'ddc') {
-    _writeSync(path.join(sdkOut, '..', 'version'),
-        new File(path.join(sdkLibIn, '..', 'version')).readAsStringSync());
-  }
 
   // Parse libraries.dart
   var sdkLibraries = _getSdkLibraries(libContents);
 
   // Enumerate core libraries and apply patches
   for (SdkLibrary library in sdkLibraries) {
-    // TODO(jmesserly): analyzer does not handle the default case of
-    // "both platforms" correctly, and treats it as being supported on neither.
-    // So instead we skip explicitly marked as either VM or dart2js libs.
-    if (mode == 'ddc' ? library.isVmLibrary : library.isDart2JsLibrary) {
+    if (library.isDart2JsLibrary) {
       continue;
     }
 
     var libraryOut = path.join(sdkLibIn, library.path);
-    var libraryIn;
-    if (mode == 'ddc' && library.path.contains(INTERNAL_PATH)) {
-      libraryIn =
-          path.join(privateIn, library.path.replaceAll(INTERNAL_PATH, ''));
-    } else {
-      libraryIn = libraryOut;
-    }
+    var libraryIn = libraryOut;
 
-    var libraryFile = new File(libraryIn);
-    if (libraryFile.existsSync()) {
+    var libraryFile = getInputFile(libraryIn, canBeMissing: true);
+    if (libraryFile != null) {
       var outPaths = <String>[libraryOut];
       var libraryContents = libraryFile.readAsStringSync();
 
@@ -124,7 +143,8 @@
           var partPath = part.uri.stringValue;
           outPaths.add(path.join(path.dirname(libraryOut), partPath));
 
-          var partFile = new File(path.join(path.dirname(libraryIn), partPath));
+          var partFile =
+              getInputFile(path.join(path.dirname(libraryIn), partPath));
           partFiles.add(partFile);
           inputModifyTime = math.max(inputModifyTime,
               partFile.lastModifiedSync().millisecondsSinceEpoch);
@@ -135,9 +155,8 @@
       var patchPath = path.join(
           patchIn, path.basenameWithoutExtension(libraryIn) + '_patch.dart');
 
-      var patchFile = new File(patchPath);
-      bool patchExists = patchFile.existsSync();
-      if (patchExists) {
+      var patchFile = getInputFile(patchPath, canBeMissing: true);
+      if (patchFile != null) {
         inputModifyTime = math.max(inputModifyTime,
             patchFile.lastModifiedSync().millisecondsSinceEpoch);
       }
@@ -162,10 +181,9 @@
       if (needsUpdate) {
         var contents = <String>[libraryContents];
         contents.addAll(partFiles.map((f) => f.readAsStringSync()));
-        if (patchExists) {
+        if (patchFile != null) {
           var patchContents = patchFile.readAsStringSync();
-          contents = _patchLibrary(
-              patchFile.path, contents, patchContents);
+          contents = _patchLibrary(patchFile.path, contents, patchContents);
         }
 
         for (var i = 0; i < outPaths.length; i++) {
@@ -175,22 +193,22 @@
     }
   }
 
-  if (mode == 'vm') {
-    for (var tuple in [['_builtin', 'builtin.dart']]) {
-      var vmLibrary = tuple[0];
-      var dartFile = tuple[1];
+  for (var tuple in [
+    ['_builtin', 'builtin.dart']
+  ]) {
+    var vmLibrary = tuple[0];
+    var dartFile = tuple[1];
 
-      // The "dart:_builtin" library is only available for the DartVM.
-      var builtinLibraryIn  = path.join(dartDir, 'runtime', 'bin', dartFile);
-      var builtinLibraryOut = path.join(sdkOut, vmLibrary, '${vmLibrary}.dart');
-      _writeSync(builtinLibraryOut, new File(builtinLibraryIn).readAsStringSync());
-    }
+    // The "dart:_builtin" library is only available for the DartVM.
+    var builtinLibraryIn = path.join(dartDir, 'runtime', 'bin', dartFile);
+    var builtinLibraryOut = path.join(sdkOut, vmLibrary, '${vmLibrary}.dart');
+    _writeSync(builtinLibraryOut, readInputFile(builtinLibraryIn));
+  }
 
-    for (var file in ['loader.dart', 'server.dart', 'vmservice_io.dart']) {
-      var libraryIn  = path.join(dartDir, 'runtime', 'bin', 'vmservice', file);
-      var libraryOut = path.join(sdkOut, 'vmservice_io', file);
-      _writeSync(libraryOut, new File(libraryIn).readAsStringSync());
-    }
+  for (var file in ['loader.dart', 'server.dart', 'vmservice_io.dart']) {
+    var libraryIn = path.join(dartDir, 'runtime', 'bin', 'vmservice', file);
+    var libraryOut = path.join(sdkOut, 'vmservice_io', file);
+    _writeSync(libraryOut, readInputFile(libraryIn));
   }
 
   // TODO(kustermann): We suppress compiler hints/warnings/errors temporarily
@@ -199,13 +217,49 @@
   // been fixed (either in fasta or the dart files in the patched_sdk).
   final capturedLines = <String>[];
   try {
+    final platform = path.join(outDir, 'platform.dill');
+
     await runZoned(() async {
       await compile_platform.mainEntryPoint(<String>[
         '--packages',
         new Uri.file(packagesFile).toString(),
         new Uri.directory(outDir).toString(),
-        path.join(outDir, 'platform.dill')
+        platform,
       ]);
+
+      // platform.dill was generated, now generate platform.dill.d depfile
+      // that captures all dependencies that participated in the generation.
+      // There are two types of dependencies:
+      //   (1) all Dart sources that constitute this tool itself
+      //   (2) Dart SDK and patch sources.
+      // We already collected all inputs from the second category in the deps
+      // set. To collect inputs from the first category we actually use Fasta:
+      // we ask Fasta to outline patch_sdk.dart and generate a depfile which
+      // would list all the sources.
+      final depfile = "${outDir}.d";
+      await CompilerCommandLine.withGlobalOptions("outline", [
+        '--packages',
+        new Uri.file(packagesFile).toString(),
+        '--platform',
+        new Uri.file(platform).toString(), // platform.dill
+        Platform.script.toString() // patch_sdk.dart
+      ], (CompilerContext c) async {
+        CompileTask task =
+            new CompileTask(c, new Ticker(isVerbose: c.options.verbose));
+        final kernelTarget = await task.buildOutline(null);
+        await kernelTarget.writeDepsFile(
+            new Uri.file(platform), new Uri.file(depfile));
+      });
+
+      // Read depfile generated by Fasta and append deps that we have collected
+      // during generation of patched_sdk to it.
+      // Note: we are splitting by ': ' because Windows paths can start with
+      // drive letter followed by a colon.
+      final list = new File(depfile).readAsStringSync().split(': ');
+      assert(list.length == 2);
+      deps.addAll(list[1].split(' ').where((str) => str.isNotEmpty));
+      assert(list[0] == path.join('patched_sdk', 'platform.dill'));
+      new File(depfile).writeAsStringSync("${list[0]}: ${deps.join(' ')}\n");
     }, zoneSpecification: new ZoneSpecification(print: (_, _2, _3, line) {
       capturedLines.add(line);
     }));
@@ -244,9 +298,8 @@
 /// in the Dart language. Since this feature is only for the convenience of
 /// writing the dart:* libraries, and not a tool given to Dart developers, it
 /// seems like a non-ideal situation. Instead we keep the preprocessing simple.
-List<String> _patchLibrary(String name,
-                           List<String> partsContents,
-                           String patchContents) {
+List<String> _patchLibrary(
+    String name, List<String> partsContents, String patchContents) {
   var results = <StringEditBuffer>[];
 
   // Parse the patch first. We'll need to extract bits of this as we go through
@@ -275,8 +328,13 @@
 }
 
 final String injectedCidFields = [
-  'Array', 'ExternalOneByteString', 'GrowableObjectArray',
-  'ImmutableArray', 'OneByteString', 'TwoByteString', 'Bigint'
+  'Array',
+  'ExternalOneByteString',
+  'GrowableObjectArray',
+  'ImmutableArray',
+  'OneByteString',
+  'TwoByteString',
+  'Bigint'
 ].map((name) => "static final int cid${name} = 0;").join('\n');
 
 /// Merge `@patch` declarations into `external` declarations.
@@ -302,8 +360,7 @@
     // make core libraries compile. Kernel reader will actually ignore these
     // fields and instead inject concrete constants into this class.
     if (node is ClassDeclaration && node.name.name == 'ClassID') {
-      code = code.replaceFirst(
-          new RegExp(r'}$'), injectedCidFields + '}');
+      code = code.replaceFirst(new RegExp(r'}$'), injectedCidFields + '}');
     }
     edits.insert(pos, '\n' + code);
   }
@@ -449,7 +506,8 @@
 
   var accessor = '';
   if (node is MethodDeclaration) {
-    if (node.isGetter) accessor = 'get:';
+    if (node.isGetter)
+      accessor = 'get:';
     else if (node.isSetter) accessor = 'set:';
   }
   return className + accessor + name;
diff --git a/tools/patch_sdk.py b/tools/patch_sdk.py
index 25e553e..212514a 100755
--- a/tools/patch_sdk.py
+++ b/tools/patch_sdk.py
@@ -48,7 +48,8 @@
     print >> sys.stderr, 'ERROR: cannot locate dart executable'
     return -1
   dart_file = os.path.join(os.path.dirname(__file__), 'patch_sdk.dart')
-  subprocess.check_call([options.dart_executable, dart_file] + args)
+  subprocess.check_call(
+      [options.dart_executable, '--checked', dart_file] + args)
   return 0
 
 if __name__ == '__main__':
diff --git a/tools/testing/dart/compiler_configuration.dart b/tools/testing/dart/compiler_configuration.dart
index b225c15..1f64f27 100644
--- a/tools/testing/dart/compiler_configuration.dart
+++ b/tools/testing/dart/compiler_configuration.dart
@@ -213,7 +213,7 @@
       CommandArtifact artifact) {
     List<String> args = [];
     if (useDFE) {
-      args.add('--dfe=utils/kernel-service/kernel-service.dart');
+      args.add('--dfe=${buildDir}/gen/kernel-service.dart.snapshot');
     }
     if (isChecked) {
       args.add('--enable_asserts');