Always store the type of a conditional expression on the node.

lib/analyzer/ast_from_analyzer.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 library kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 312 matching lines @@
   ast.Supertype buildSupertype(DartType type) {
     if (type is InterfaceType) {
       var classElement = type.element;
       if (classElement == null) return getRootClassReference().asRawSupertype;
       var classNode = getClassReference(classElement);
       if (classNode.typeParameters.isEmpty ||
           classNode.typeParameters.length != type.typeArguments.length) {
         return classNode.asRawSupertype;
       } else {
         return new ast.Supertype(classNode,
-          type.typeArguments.map(buildType).toList(growable: false));
+            type.typeArguments.map(buildType).toList(growable: false));
       }
     }
     return getRootClassReference().asRawSupertype;
   }
 
   ast.DartType buildTypeAnnotation(AstNode node) {
     return new TypeAnnotationBuilder(this).build(node);
   }
 
   ast.DartType buildOptionalTypeAnnotation(AstNode node) {
@@ skipping 52 matching lines @@
   }
 
   List<ast.TypeParameter> buildOptionalTypeParameterList(
       TypeParameterList node) {
     if (node == null) return <ast.TypeParameter>[];
     return node.typeParameters.map(buildTypeParameter).toList();
   }
 
   ast.TypeParameter buildTypeParameter(TypeParameter node) {
     return makeTypeParameter(node.element,
-        bound:
-            buildOptionalTypeAnnotation(node.bound) ??
+        bound: buildOptionalTypeAnnotation(node.bound) ??
             defaultTypeParameterBound);
   }
 
   ConstructorElement findDefaultConstructor(ClassElement class_) {
     for (var constructor in class_.constructors) {
       // Note: isDefaultConstructor checks if the constructor is suitable for
       // being invoked without arguments.  It does not imply that it is
       // synthetic.
       if (constructor.isDefaultConstructor && !constructor.isFactory) {
         return constructor;
@@ skipping 257 matching lines @@
     if (positionals.isNotEmpty &&
         parameters[positionals.length - 1].parameterKind == named) {
       return false; // Too many positional arguments.
     }
     if (arguments.named.isEmpty) return true;
     int firstNamedParameter = positionals.length;
     while (firstNamedParameter < parameters.length &&
         parameters[firstNamedParameter].parameterKind != ParameterKind.NAMED) {
       ++firstNamedParameter;
     }
-    namedLoop: for (int i = 0; i < arguments.named.length; ++i) {
+    namedLoop:
+    for (int i = 0; i < arguments.named.length; ++i) {
       String name = arguments.named[i].name;
       for (int j = firstNamedParameter; j < parameters.length; ++j) {
         if (parameters[j].parameterKind == ParameterKind.NAMED &&
             parameters[j].name == name) {
           continue namedLoop;
         }
       }
       return false;
     }
     return true;
@@ skipping 621 matching lines @@
   }
 
   ast.Expression visitAssignmentExpression(AssignmentExpression node) {
     bool voidContext = isInVoidContext(node);
     String operator = node.operator.value();
     var leftHand = buildLeftHandValue(node.leftHandSide);
     var rightHand = build(node.rightHandSide);
     if (operator == '=') {
       return leftHand.buildAssignment(rightHand, voidContext: voidContext);
     } else if (operator == '??=') {
-      return leftHand.buildNullAwareAssignment(rightHand,
+      return leftHand.buildNullAwareAssignment(
+          rightHand, scope.buildType(node.staticType),
           voidContext: voidContext);
     } else {
       // Cut off the trailing '='.
       var name = new ast.Name(operator.substring(0, operator.length - 1));
       return leftHand.buildCompoundAssignment(name, rightHand,
           voidContext: voidContext,
           interfaceTarget: scope.resolveInterfaceMethod(node.staticElement));
     }
   }
 
@@ skipping 345 matching lines @@
       var inferredType = scope.getInferredType(node);
       if (inferredType is ast.InterfaceType) {
         return inferredType.typeArguments.toList();
       }
       int numberOfTypeArguments =
           classElement == null ? 0 : classElement.typeParameters.length;
       return new List<ast.DartType>.filled(
           numberOfTypeArguments, const ast.DynamicType(),
           growable: true);
     }
+
     var arguments = buildArguments(node.argumentList,
         explicitTypeArguments: node.constructorName.type.typeArguments,
         inferTypeArguments: inferTypeArguments);
     ast.Expression noSuchMethodError() {
       return node.isConst
           ? scope.emitInvalidConstant()
           : scope.buildThrowNoSuchMethodError(
               new ast.NullLiteral(), '${node.constructorName}', arguments,
               candidateTarget: element);
     }
+
     if (element == null) {
       return noSuchMethodError();
     }
     assert(classElement != null);
     var redirect = getEffectiveFactoryTarget(element);
     if (redirect == null) {
       return scope.buildThrowCompileTimeError(
           CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT.message);
     }
     if (redirect != element) {
@@ skipping 131 matching lines @@
       var receiver = makeOrReuseVariable(build(target));
       return makeLet(
           receiver,
           new ast.ConditionalExpression(
               buildIsNull(new ast.VariableGet(receiver)),
               new ast.NullLiteral(),
               buildDecomposableMethodInvocation(
                   new ast.VariableGet(receiver),
                   scope.buildName(node.methodName),
                   buildArgumentsForInvocation(node),
-                  element)));
+                  element),
+              scope.buildType(node.staticType)));
     } else {
       return buildDecomposableMethodInvocation(
           build(node.target),
           scope.buildName(node.methodName),
           buildArgumentsForInvocation(node),
           element);
     }
   }
 
   ast.Expression visitNamedExpression(NamedExpression node) {
@@ skipping 74 matching lines @@
       return new SuperPropertyAccessor(
           scope.buildName(node.propertyName),
           scope.resolveConcreteGet(element, auxiliary),
           scope.resolveConcreteSet(element, auxiliary));
     } else if (target is Identifier && target.staticElement is ClassElement) {
       // Note that this case also covers null-aware static access on a class,
       // which is equivalent to a regular static access.
       return scope.staticAccess(node.propertyName.name, element, auxiliary);
     } else if (node.operator.value() == '?.') {
       return new NullAwarePropertyAccessor(
-          build(target), scope.buildName(node.propertyName), getter, setter);
+          build(target), scope.buildName(node.propertyName), getter, setter,
+          scope.buildType(node.staticType));
     } else {
       return PropertyAccessor.make(
           build(target), scope.buildName(node.propertyName), getter, setter);
     }
   }
 
   ast.Expression visitRethrowExpression(RethrowExpression node) {
     return new ast.Rethrow();
   }
 
@@ skipping 664 matching lines @@
       // Redirecting factories with resolved targets don't show up here.
       assert(node.element.redirectedConstructor == null);
       var function = procedure.function;
       var name = node.redirectedConstructor.type.name.name;
       if (node.redirectedConstructor.name != null) {
         name += '.' + node.redirectedConstructor.name.name;
       }
       // TODO(asgerf): Sometimes a TypeError should be thrown.
       function.body = new ast.ExpressionStatement(
           scope.buildThrowNoSuchMethodError(
-              new ast.NullLiteral(),
-              name,
-              new ast.Arguments.empty()))..parent = function;
+              new ast.NullLiteral(), name, new ast.Arguments.empty()))
+        ..parent = function;
     }
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
     addAnnotations(node.metadata);
     ast.Procedure procedure = currentMember;
     procedure.function = scope.buildFunctionNode(node.parameters, node.body,
         returnType: node.returnType,
         inferredReturnType: scope.buildType(node.element.returnType),
         typeParameters:
@@ skipping 125 matching lines @@
   if (element is FieldElement) return element.getter;
   return element;
 }
 
 Element desynthesizeSetter(Element element) {
   if (element == null || !element.isSynthetic) return element;
   if (element is PropertyAccessorElement) return element.variable;
   if (element is FieldElement) return element.setter;
   return element;
 }