Only set types of conditional expressions in strong mode.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // 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.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 395 matching lines @@
     }
   }
 }
 
 /// Concrete shadow object representing a conditional expression in kernel form.
 /// Shadow object for [ConditionalExpression].
 class KernelConditionalExpression extends ConditionalExpression
     implements KernelExpression {
   KernelConditionalExpression(
       Expression condition, Expression then, Expression otherwise)
-      : super(condition, then, otherwise, const DynamicType());
+      : super(condition, then, otherwise, null);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // Inference dependencies are the union of the inference dependencies of the
     // two returned sub-expressions.
     collector.collectDependencies(then);
     collector.collectDependencies(otherwise);
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.conditionalExpressionEnter(this, typeContext) ||
             typeNeeded;
     if (!inferrer.isTopLevel) {
       inferrer.inferExpression(
           condition, inferrer.coreTypes.boolClass.rawType, false);
     }
     DartType thenType = inferrer.inferExpression(then, typeContext, true);
     DartType otherwiseType =
         inferrer.inferExpression(otherwise, typeContext, true);
     DartType type = inferrer.typeSchemaEnvironment
         .getLeastUpperBound(thenType, otherwiseType);
-    staticType = type;
+    if (inferrer.strongMode) {
+      staticType = type;
+    }
     var inferredType = typeNeeded ? type : null;
     inferrer.listener.conditionalExpressionExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [ConstructorInvocation].
 class KernelConstructorInvocation extends ConstructorInvocation
     implements KernelExpression {
   final Member _initialTarget;
@@ skipping 480 matching lines @@
     collector.recordNotImmediatelyEvident(fileOffset);
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.ifNullEnter(this, typeContext) || typeNeeded;
     // To infer `e0 ?? e1` in context K:
     // - Infer e0 in context K to get T0
     var lhsType = inferrer.inferExpression(_lhs, typeContext, true);
-    variable.type = lhsType;
+    if (inferrer.strongMode) {
+      variable.type = lhsType;
+    }
     // - Let J = T0 if K is `_` else K.
     var rhsContext = typeContext ?? lhsType;
     // - Infer e1 in context J to get T1
     var rhsType =
         inferrer.inferExpression(_rhs, rhsContext, typeContext == null);
     // - Let T = greatest closure of K with respect to `?` if K is not `_`, else
     //   UP(t0, t1)
     // - Then the inferred type is T.
     var inferredType = typeContext == null
         ? inferrer.typeSchemaEnvironment.getLeastUpperBound(lhsType, rhsType)
         : greatestClosure(inferrer.coreTypes, typeContext);
-    body.staticType = inferredType;
+    if (inferrer.strongMode) {
+      body.staticType = inferredType;
+    }
     inferrer.listener.ifNullExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing an if statement in kernel form.
 class KernelIfStatement extends IfStatement implements KernelStatement {
   KernelIfStatement(Expression condition, Statement then, Statement otherwise)
       : super(condition, then, otherwise);
 
@@ skipping 425 matching lines @@
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     var inferredType = inferrer.inferMethodInvocation(
         this,
         variable.initializer,
         fileOffset,
         _desugaredInvocation,
         false,
         typeContext,
-        true,
+        typeNeeded || inferrer.strongMode,
         receiverVariable: variable);
-    body.staticType = inferredType;
+    if (inferrer.strongMode) {
+      body.staticType = inferredType;
+    }
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a null-aware read from a property.
 ///
 /// A null-aware property get of the form `a?.b` is represented as the kernel
 /// expression:
 ///
 ///     let v = a in v == null ? null : v.b
 class KernelNullAwarePropertyGet extends Let implements KernelExpression {
   KernelNullAwarePropertyGet(
       VariableDeclaration variable, ConditionalExpression body)
       : super(variable, body);
 
   @override
   ConditionalExpression get body => super.body;
 
   PropertyGet get _desugaredGet => body.otherwise;
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // Null aware expressions are not immediately evident.
     collector.recordNotImmediatelyEvident(fileOffset);
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
-    var inferredType = inferrer.inferPropertyGet(this, variable.initializer,
-        fileOffset, _desugaredGet, typeContext, true,
+    var inferredType = inferrer.inferPropertyGet(
+        this,
+        variable.initializer,
+        fileOffset,
+        _desugaredGet,
+        typeContext,
+        typeNeeded || inferrer.strongMode,
         receiverVariable: variable);
-    body.staticType = inferredType;
+    if (inferrer.strongMode) {
+      body.staticType = inferredType;
+    }
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a null literal in kernel form.
 class KernelNullLiteral extends NullLiteral implements KernelExpression {
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // No inference dependencies.
   }
@@ skipping 819 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }