Use KernelTypeGraphBuilder in KernelInferrerEngine

pkg/compiler/lib/src/inferrer/builder.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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 45 matching lines @@
         SetBulkMixin<TypeInformation, dynamic>
     implements SemanticSendVisitor<TypeInformation, dynamic> {
   final Compiler compiler;
   final MemberElement analyzedElement;
   final ResolvedAst resolvedAst;
   final TypeSystem<ast.Node> types;
   final Map<JumpTarget, List<LocalsHandler>> breaksFor =
       new Map<JumpTarget, List<LocalsHandler>>();
   final Map<JumpTarget, List<LocalsHandler>> continuesFor =
       new Map<JumpTarget, List<LocalsHandler>>();
-  LocalsHandler locals;
+  LocalsHandler<ast.Node> locals;
   final List<TypeInformation> cascadeReceiverStack =
       new List<TypeInformation>();
 
   TypeInformation returnType;
   bool visitingInitializers = false;
   bool isConstructorRedirect = false;
   bool seenSuperConstructorCall = false;
   SideEffects sideEffects = new SideEffects.empty();
   final MemberElement outermostElement;
   final InferrerEngine inferrer;
@@ skipping 12 matching lines @@
         this.types = inferrer.types,
         this.memberData = inferrer.dataOfMember(analyzedElement.memberContext) {
     assert(analyzedElement.isDeclaration);
     assert(outermostElement != null);
     assert(outermostElement.isDeclaration);
     if (locals != null) return;
     ast.Node node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
-    FieldInitializationScope fieldScope =
+    FieldInitializationScope<ast.Node> fieldScope =
         analyzedElement.isGenerativeConstructor
-            ? new FieldInitializationScope(types)
+            ? new FieldInitializationScope<ast.Node>(types)
             : null;
-    locals =
-        new LocalsHandler(inferrer, types, compiler.options, node, fieldScope);
+    locals = new LocalsHandler<ast.Node>(
+        inferrer, types, compiler.options, node, fieldScope);
   }
 
   ElementGraphBuilder(
       MemberElement element, Compiler compiler, InferrerEngine inferrer,
       [LocalsHandler handler])
       : this.internal(element, element.resolvedAst,
             element.memberContext.declaration, inferrer, compiler, handler);
 
   TreeElements get elements => resolvedAst.elements;
 
@@ skipping 254 matching lines @@
     isChecks.add(node);
   }
 
   void potentiallyAddNullCheck(ast.Send node, ast.Node receiver) {
     if (!accumulateIsChecks) return;
     if (!Elements.isLocal(elements[receiver])) return;
     isChecks.add(node);
   }
 
   void updateIsChecks(List<ast.Node> tests, {bool usePositive}) {
-    void narrow(Element element, ResolutionDartType type, ast.Node node) {
-      if (element is LocalElement) {
-        TypeInformation existing = locals.use(element);
-        TypeInformation newType =
-            types.narrowType(existing, type, isNullable: false);
-        locals.update(element, newType, node);
-      }
-    }
-
     if (tests == null) return;
     for (ast.Send node in tests) {
       if (node.isTypeTest) {
         if (node.isIsNotCheck) {
           if (usePositive) continue;
         } else {
           if (!usePositive) continue;
         }
         ResolutionDartType type =
             elements.getType(node.typeAnnotationFromIsCheckOrCast);
-        narrow(elements[node.receiver], type, node);
+        Element element = elements[node.receiver];
+        if (Elements.isLocal(element)) {
+          LocalElement local = element;
+          locals.narrow(local, type, node);
+        }
       } else {
         Element receiverElement = elements[node.receiver];
         Element argumentElement = elements[node.arguments.first];
         String operator = node.selector.asOperator().source;
         if ((operator == '==' && usePositive) ||
             (operator == '!=' && !usePositive)) {
           // Type the elements as null.
           if (Elements.isLocal(receiverElement)) {
-            locals.update(receiverElement, types.nullType, node);
+            LocalElement local = receiverElement;
+            locals.update(local, types.nullType, node, local.type);
           }
           if (Elements.isLocal(argumentElement)) {
-            locals.update(argumentElement, types.nullType, node);
+            LocalElement local = argumentElement;
+            locals.update(local, types.nullType, node, local.type);
           }
         } else {
           // Narrow the elements to a non-null type.
           ResolutionInterfaceType objectType =
               closedWorld.commonElements.objectType;
           if (Elements.isLocal(receiverElement)) {
-            narrow(receiverElement, objectType, node);
+            LocalElement local = receiverElement;
+            locals.narrow(local, objectType, node);
           }
           if (Elements.isLocal(argumentElement)) {
-            narrow(argumentElement, objectType, node);
+            LocalElement local = argumentElement;
+            locals.narrow(local, objectType, node);
           }
         }
       }
     }
   }
 
   @override
   TypeInformation visitIndex(
       ast.Send node, ast.Node receiver, ast.Node index, _) {
     return handleDynamicInvoke(node);
@@ skipping 158 matching lines @@
     TypeInformation type = types.allocateDiamondPhi(firstType, secondType);
     return type;
   }
 
   TypeInformation visitVariableDefinitions(ast.VariableDefinitions node) {
     for (Link<ast.Node> link = node.definitions.nodes;
         !link.isEmpty;
         link = link.tail) {
       ast.Node definition = link.head;
       if (definition is ast.Identifier) {
-        locals.update(elements[definition], types.nullType, node);
+        LocalElement local = elements[definition];
+        locals.update(local, types.nullType, node, local.type);
       } else {
         assert(definition.asSendSet() != null);
         handleSendSet(definition);
       }
     }
     return null;
   }
 
   bool handleCondition(ast.Node node, List<ast.Send> tests) {
     bool oldConditionIsSimple = conditionIsSimple;
@@ skipping 135 matching lines @@
     ast.Node exception = node.exception;
     if (exception != null) {
       ResolutionDartType type = elements.getType(node.type);
       TypeInformation mask;
       if (type == null || type.treatAsDynamic || type.isTypeVariable) {
         mask = types.dynamicType;
       } else {
         ResolutionInterfaceType interfaceType = type;
         mask = types.nonNullSubtype(interfaceType.element);
       }
-      locals.update(elements[exception], mask, node);
+      LocalElement local = elements[exception];
+      locals.update(local, mask, node, local.type);
     }
     ast.Node trace = node.trace;
     if (trace != null) {
-      locals.update(elements[trace], types.dynamicType, node);
+      LocalElement local = elements[trace];
+      locals.update(local, types.dynamicType, node, local.type);
     }
     visit(node.block);
     return null;
   }
 
   TypeInformation visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
     return visit(node.expression);
   }
 
@@ skipping 217 matching lines @@
           InitializingFormalElement initializingFormal = element;
           if (initializingFormal.fieldElement.isFinal) {
             inferrer.recordTypeOfField(
                 initializingFormal.fieldElement, parameterType);
           } else {
             locals.updateField(initializingFormal.fieldElement, parameterType);
             inferrer.recordTypeOfField(
                 initializingFormal.fieldElement, parameterType);
           }
         }
-        locals.update(element, parameterType, node);
+        locals.update(element, parameterType, node, element.type);
       });
       ClassElement cls = analyzedConstructor.enclosingClass;
       Spannable spannable = node;
       if (analyzedConstructor.isSynthesized) {
         spannable = analyzedConstructor;
         synthesizeForwardingCall(
             spannable, analyzedConstructor.definingConstructor);
       } else {
         visitingInitializers = true;
         if (node.initializers != null) {
@@ skipping 43 matching lines @@
           // TODO(johnniwinther): Avoid analyzing [analyzedElement] in this
           // case; it's never called.
           returnType = types.nonNullEmpty();
         }
       } else {
         returnType = types.nonNullExact(cls);
       }
     } else {
       signature.forEachParameter((FormalElement _element) {
         ParameterElement element = _element;
-        locals.update(element, inferrer.typeOfParameter(element), node);
+        locals.update(
+            element, inferrer.typeOfParameter(element), node, element.type);
       });
       visit(node.body);
       switch (function.asyncMarker) {
         case AsyncMarker.SYNC:
           if (returnType == null) {
             // No return in the body.
             returnType = locals.seenReturnOrThrow
                 ? types.nonNullEmpty() // Body always throws.
                 : types.nullType;
           } else if (!locals.seenReturnOrThrow) {
@@ skipping 65 matching lines @@
     });
   }
 
   TypeInformation visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element =
         elements.getFunctionDefinition(node.function);
     TypeInformation type =
         inferrer.concreteTypes.putIfAbsent(node.function, () {
       return types.allocateClosure(element.callMethod);
     });
-    locals.update(element, type, node);
+    locals.update(element, type, node, element.type);
     visit(node.function);
     return type;
   }
 
   TypeInformation visitStringInterpolation(ast.StringInterpolation node) {
     // Interpolation could have any effects since it could call any toString()
     // method.
     // TODO(sra): This could be modelled by a call to toString() but with a
     // guaranteed String return type.  Interpolation of known types would get
     // specialized effects.  This would not currently be effective since the JS
@@ skipping 192 matching lines @@
 
       if (Elements.isStaticOrTopLevelField(element)) {
         handleStaticSend(node, setterSelector, setterMask, element,
             new ArgumentsTypes([newType], null));
       } else if (Elements.isUnresolved(element) ||
           element.isSetter ||
           element.isField) {
         handleDynamicSend(CallType.complex, node, setterSelector, setterMask,
             receiverType, new ArgumentsTypes([newType], null));
       } else if (element.isLocal) {
-        locals.update(element, newType, node);
+        LocalElement local = element;
+        locals.update(local, newType, node, local.type,
+            isSetIfNull: node.isIfNullAssignment);
       }
 
       return node.isPostfix ? getterType : newType;
     }
   }
 
   /// Handle compound index set, like `foo[0] += 42` or `foo[0]++`.
   TypeInformation handleCompoundIndexSet(
       ast.SendSet node,
       TypeInformation receiverType,
@@ skipping 629 matching lines @@
           (node.asSendSet().receiver != null) &&
           node.asSendSet().receiver.isThis()) {
         Iterable<MemberEntity> targets = closedWorld.locateMembers(
             setterSelector, types.newTypedSelector(thisType, setterMask));
         // We just recognized a field initialization of the form:
         // `this.foo = 42`. If there is only one target, we can update
         // its type.
         if (targets.length == 1) {
           MemberElement single = targets.first;
           if (single.isField) {
-            locals.updateField(single, rhsType);
+            FieldElement field = single;
+            locals.updateField(field, rhsType);
           }
         }
       }
       handleDynamicSend(CallType.access, node, setterSelector, setterMask,
           receiverType, arguments);
     } else if (element.isField) {
       FieldElement field = element;
       if (field.isFinal) {
         inferrer.recordTypeOfField(field, rhsType);
       } else {
         if (analyzedElement.isGenerativeConstructor) {
           locals.updateField(field, rhsType);
         }
         if (visitingInitializers) {
           inferrer.recordTypeOfField(field, rhsType);
         } else {
           handleDynamicSend(CallType.complex, node, setterSelector, setterMask,
               receiverType, arguments);
         }
       }
     } else if (element.isLocal) {
-      locals.update(element, rhsType, node);
+      LocalElement local = element;
+      ast.SendSet sendSet = node.asSendSet();
+      bool isSetIfNull = sendSet != null && sendSet.isIfNullAssignment;
+      locals.update(local, rhsType, node, local.type, isSetIfNull: isSetIfNull);
     }
     return rhsType;
   }
 
   /// Handle a super access or invocation that results in a `noSuchMethod` call.
   TypeInformation handleErroneousSuperSend(ast.Send node) {
     ArgumentsTypes arguments =
         node.isPropertyAccess ? null : analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
     TypeMask mask = memberData.typeOfSend(node);
@@ skipping 733 matching lines @@
     ast.Send send = node.asSend();
     bool isConditional = false;
     if (send != null) {
       isConditional = send.isConditional;
       ast.Node receiver = send.receiver;
       if (receiver != null) {
         Element element = elements[receiver];
         if (Elements.isLocal(element) && !capturedVariables.contains(element)) {
           TypeInformation refinedType = types.refineReceiver(
               selector, mask, receiverType, send.isConditional);
-          locals.update(element, refinedType, node);
+          LocalElement local = element;
+          locals.update(local, refinedType, node, local.type);
         }
       }
     }
 
     return inferrer.registerCalledSelector(
         callType,
         node,
         selector,
         mask,
         receiverType,
@@ skipping 186 matching lines @@
         node,
         iteratorSelector,
         iteratorMask,
         expressionType,
         new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }