Fix for type analysis bug in constructor with early return

pkg/compiler/lib/src/inferrer/locals_handler.dart

 // Copyright (c) 2013, 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 locals_handler;
 
 import 'dart:collection' show IterableMixin;
 
 import '../options.dart' show CompilerOptions;
 import '../elements/elements.dart';
@@ skipping 84 matching lines @@
     if (variables == null) return false;
     return variables.containsKey(variable);
   }
 
   String toString() {
     String rest = parent == null ? "null" : parent.toString();
     return '$variables $rest';
   }
 }
 
+/// Tracks initializers via initializations and assignments.
 class FieldInitializationScope {
   final TypeSystem types;
   Map<Element, TypeInformation> fields;
   bool isThisExposed;
 
-  FieldInitializationScope(this.types) : isThisExposed = false;
+  /// `true` when control flow prevents accumulating definite assignments,
+  /// e.g. an early return or caught exception.
+  bool isIndefinite;
+
+  FieldInitializationScope(this.types)
+      : isThisExposed = false,
+        isIndefinite = false;
 
   FieldInitializationScope.internalFrom(FieldInitializationScope other)
       : types = other.types,
-        isThisExposed = other.isThisExposed;
+        isThisExposed = other.isThisExposed,
+        isIndefinite = other.isIndefinite;
 
   factory FieldInitializationScope.from(FieldInitializationScope other) {
     if (other == null) return null;
     return new FieldInitializationScope.internalFrom(other);
   }
 
   void updateField(Element field, TypeInformation type) {
     if (isThisExposed) return;
-    if (fields == null) fields = new Map<Element, TypeInformation>();
+    if (isIndefinite) return;
+    fields ??= new Map<Element, TypeInformation>();
     fields[field] = type;
   }
 
   TypeInformation readField(Element field) {
     return fields == null ? null : fields[field];
   }
 
   void forEach(void f(Element element, TypeInformation type)) {
-    if (fields == null) return;
-    fields.forEach(f);
+    fields?.forEach(f);
   }
 
   void mergeDiamondFlow(
       FieldInitializationScope thenScope, FieldInitializationScope elseScope) {
-    // Quick bailout check. If [isThisExposed] is true, we know the
-    // code following won'TypeInformation do anything.
+    // Quick bailout check. If [isThisExposed] or [isIndefinite] is true, we
+    // know the code following won'TypeInformation do anything.
     if (isThisExposed) return;
-    if (elseScope == null || elseScope.fields == null) {
-      elseScope = this;
-    }
+    if (isIndefinite) return;
+
+    FieldInitializationScope otherScope =
+        (elseScope == null || elseScope.fields == null) ? this : elseScope;
 
     thenScope.forEach((Element field, TypeInformation type) {
-      TypeInformation otherType = elseScope.readField(field);
+      TypeInformation otherType = otherScope.readField(field);
       if (otherType == null) return;
       updateField(field, types.allocateDiamondPhi(type, otherType));
     });
+
     isThisExposed = thenScope.isThisExposed || elseScope.isThisExposed;
+    isIndefinite = thenScope.isIndefinite || elseScope.isIndefinite;
   }
 }
 
 /**
  * Placeholder for inferred arguments types on sends.
  */
 class ArgumentsTypes extends IterableMixin<TypeInformation> {
   final List<TypeInformation> positional;
   final Map<String, TypeInformation> named;
   ArgumentsTypes(this.positional, named)
@@ skipping 371 matching lines @@
       if (newType != type) {
         locals[variable] = newType;
       }
     });
   }
 
   void updateField(Element element, TypeInformation type) {
     fieldScope.updateField(element, type);
   }
 }