Rename UnlinkedConst -> UnlinkedExpr

pkg/analyzer/lib/src/summary/link.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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 1431 matching lines @@
           ConstructorElementForLink constructor = constructorElement
               .enclosingClass
               .getContainedName(constructorInitializer.name)
               .asConstructor;
           safeAddDependency(constructor?._constNode);
         }
         CompilationUnitElementForLink compilationUnit =
             constructorElement.enclosingElement.enclosingElement;
         collectDependencies(
             dependencies, constructorInitializer.expression, compilationUnit);
-        for (UnlinkedConst unlinkedConst in constructorInitializer.arguments) {
+        for (UnlinkedExpr unlinkedConst in constructorInitializer.arguments) {
           collectDependencies(dependencies, unlinkedConst, compilationUnit);
         }
       }
 
       if (defaultSuperInvocationNeeded) {
         // No explicit superconstructor invocation found, so we need to
         // manually insert a reference to the implicit superconstructor.
         if (superClass != null && !superClass.isObject) {
           ConstructorElementForLink unnamedConstructor =
               superClass.unnamedConstructor;
@@ skipping 64 matching lines @@
   @override
   bool isEvaluated = false;
 
   /**
    * Collect the dependencies in [unlinkedConst] (which should be
    * interpreted relative to [compilationUnit]) and store them in
    * [dependencies].
    */
   void collectDependencies(
       List<ConstNode> dependencies,
-      UnlinkedConst unlinkedConst,
+      UnlinkedExpr unlinkedConst,
       CompilationUnitElementForLink compilationUnit) {
     if (unlinkedConst == null) {
       return;
     }
     int refPtr = 0;
     int intPtr = 0;
-    for (UnlinkedConstOperation operation in unlinkedConst.operations) {
+    for (UnlinkedExprOperation operation in unlinkedConst.operations) {
       switch (operation) {
-        case UnlinkedConstOperation.pushInt:
+        case UnlinkedExprOperation.pushInt:
           intPtr++;
           break;
-        case UnlinkedConstOperation.pushLongInt:
+        case UnlinkedExprOperation.pushLongInt:
           int numInts = unlinkedConst.ints[intPtr++];
           intPtr += numInts;
           break;
-        case UnlinkedConstOperation.concatenate:
+        case UnlinkedExprOperation.concatenate:
           intPtr++;
           break;
-        case UnlinkedConstOperation.pushReference:
+        case UnlinkedExprOperation.pushReference:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstVariableNode variable =
               compilationUnit.resolveRef(ref.reference).asConstVariable;
           if (variable != null) {
             dependencies.add(variable);
           }
           break;
-        case UnlinkedConstOperation.makeUntypedList:
-        case UnlinkedConstOperation.makeUntypedMap:
+        case UnlinkedExprOperation.makeUntypedList:
+        case UnlinkedExprOperation.makeUntypedMap:
           intPtr++;
           break;
-        case UnlinkedConstOperation.assignToRef:
+        case UnlinkedExprOperation.assignToRef:
           refPtr++;
           break;
-        case UnlinkedConstOperation.invokeMethodRef:
+        case UnlinkedExprOperation.invokeMethodRef:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstVariableNode variable =
               compilationUnit.resolveRef(ref.reference).asConstVariable;
           if (variable != null) {
             dependencies.add(variable);
           }
           intPtr += 2;
           int numTypeArguments = unlinkedConst.ints[intPtr++];
           refPtr += numTypeArguments;
           break;
-        case UnlinkedConstOperation.invokeMethod:
+        case UnlinkedExprOperation.invokeMethod:
           intPtr += 2;
           int numTypeArguments = unlinkedConst.ints[intPtr++];
           refPtr += numTypeArguments;
           break;
-        case UnlinkedConstOperation.makeTypedList:
+        case UnlinkedExprOperation.makeTypedList:
           refPtr++;
           intPtr++;
           break;
-        case UnlinkedConstOperation.makeTypedMap:
+        case UnlinkedExprOperation.makeTypedMap:
           refPtr += 2;
           intPtr++;
           break;
-        case UnlinkedConstOperation.invokeConstructor:
+        case UnlinkedExprOperation.invokeConstructor:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstructorElementForLink element =
               compilationUnit.resolveRef(ref.reference).asConstructor;
           if (element?._constNode != null) {
             dependencies.add(element._constNode);
           }
           intPtr += 2;
           break;
-        case UnlinkedConstOperation.typeCast:
-        case UnlinkedConstOperation.typeCheck:
+        case UnlinkedExprOperation.typeCast:
+        case UnlinkedExprOperation.typeCheck:
           refPtr++;
           break;
-        case UnlinkedConstOperation.pushLocalFunctionReference:
+        case UnlinkedExprOperation.pushLocalFunctionReference:
           intPtr += 2;
           break;
         default:
           break;
       }
     }
     assert(refPtr == unlinkedConst.references.length);
     assert(intPtr == unlinkedConst.ints.length);
   }
 }
@@ skipping 446 matching lines @@
     }
   }
 }
 
 class ExprTypeComputer {
   final FunctionElementForLink_Local function;
   final CompilationUnitElementForLink unit;
   final LibraryElementForLink library;
   final Linker linker;
   final TypeProvider typeProvider;
-  final UnlinkedConst unlinkedConst;
+  final UnlinkedExpr unlinkedConst;
 
   final List<DartType> stack = <DartType>[];
   int intPtr = 0;
   int refPtr = 0;
   int strPtr = 0;
   int assignmentOperatorPtr = 0;
 
   factory ExprTypeComputer(FunctionElementForLink_Local functionElement) {
     CompilationUnitElementForLink unit = functionElement.compilationUnit;
     LibraryElementForLink library = unit.enclosingElement;
     Linker linker = library._linker;
     TypeProvider typeProvider = linker.typeProvider;
-    UnlinkedConst unlinkedConst = functionElement._unlinkedExecutable.bodyExpr;
+    UnlinkedExpr unlinkedConst = functionElement._unlinkedExecutable.bodyExpr;
     return new ExprTypeComputer._(
         functionElement, unit, library, linker, typeProvider, unlinkedConst);
   }
 
   ExprTypeComputer._(this.function, this.unit, this.library, this.linker,
       this.typeProvider, this.unlinkedConst);
 
   DartType compute() {
     if (unlinkedConst == null) {
       // No function body was stored for this function, so we can't infer its
       // return type.  Assume `dynamic`.
       return DynamicTypeImpl.instance;
     }
     // Perform RPN evaluation of the constant, using a stack of inferred types.
-    for (UnlinkedConstOperation operation in unlinkedConst.operations) {
+    for (UnlinkedExprOperation operation in unlinkedConst.operations) {
       switch (operation) {
-        case UnlinkedConstOperation.pushInt:
+        case UnlinkedExprOperation.pushInt:
           intPtr++;
           stack.add(typeProvider.intType);
           break;
-        case UnlinkedConstOperation.pushLongInt:
+        case UnlinkedExprOperation.pushLongInt:
           int numInts = _getNextInt();
           intPtr += numInts;
           stack.add(typeProvider.intType);
           break;
-        case UnlinkedConstOperation.pushDouble:
+        case UnlinkedExprOperation.pushDouble:
           stack.add(typeProvider.doubleType);
           break;
-        case UnlinkedConstOperation.pushTrue:
-        case UnlinkedConstOperation.pushFalse:
+        case UnlinkedExprOperation.pushTrue:
+        case UnlinkedExprOperation.pushFalse:
           stack.add(typeProvider.boolType);
           break;
-        case UnlinkedConstOperation.pushString:
+        case UnlinkedExprOperation.pushString:
           strPtr++;
           stack.add(typeProvider.stringType);
           break;
-        case UnlinkedConstOperation.concatenate:
+        case UnlinkedExprOperation.concatenate:
           stack.length -= _getNextInt();
           stack.add(typeProvider.stringType);
           break;
-        case UnlinkedConstOperation.makeSymbol:
+        case UnlinkedExprOperation.makeSymbol:
           strPtr++;
           stack.add(typeProvider.symbolType);
           break;
-        case UnlinkedConstOperation.pushNull:
+        case UnlinkedExprOperation.pushNull:
           stack.add(BottomTypeImpl.instance);
           break;
-        case UnlinkedConstOperation.pushReference:
+        case UnlinkedExprOperation.pushReference:
           _doPushReference();
           break;
-        case UnlinkedConstOperation.extractProperty:
+        case UnlinkedExprOperation.extractProperty:
           _doExtractProperty();
           break;
-        case UnlinkedConstOperation.invokeConstructor:
+        case UnlinkedExprOperation.invokeConstructor:
           _doInvokeConstructor();
           break;
-        case UnlinkedConstOperation.makeUntypedList:
+        case UnlinkedExprOperation.makeUntypedList:
           _doMakeUntypedList();
           break;
-        case UnlinkedConstOperation.makeUntypedMap:
+        case UnlinkedExprOperation.makeUntypedMap:
           _doMakeUntypedMap();
           break;
-        case UnlinkedConstOperation.makeTypedList:
+        case UnlinkedExprOperation.makeTypedList:
           _doMakeTypedList();
           break;
-        case UnlinkedConstOperation.makeTypedMap:
+        case UnlinkedExprOperation.makeTypedMap:
           _doMakeTypeMap();
           break;
-        case UnlinkedConstOperation.not:
+        case UnlinkedExprOperation.not:
           stack.length -= 1;
           stack.add(typeProvider.boolType);
           break;
-        case UnlinkedConstOperation.complement:
+        case UnlinkedExprOperation.complement:
           _computePrefixExpressionType('~');
           break;
-        case UnlinkedConstOperation.negate:
+        case UnlinkedExprOperation.negate:
           _computePrefixExpressionType('unary-');
           break;
-        case UnlinkedConstOperation.and:
-        case UnlinkedConstOperation.or:
-        case UnlinkedConstOperation.equal:
-        case UnlinkedConstOperation.notEqual:
+        case UnlinkedExprOperation.and:
+        case UnlinkedExprOperation.or:
+        case UnlinkedExprOperation.equal:
+        case UnlinkedExprOperation.notEqual:
           stack.length -= 2;
           stack.add(typeProvider.boolType);
           break;
-        case UnlinkedConstOperation.bitXor:
+        case UnlinkedExprOperation.bitXor:
           _computeBinaryExpressionType(TokenType.CARET);
           break;
-        case UnlinkedConstOperation.bitAnd:
+        case UnlinkedExprOperation.bitAnd:
           _computeBinaryExpressionType(TokenType.AMPERSAND);
           break;
-        case UnlinkedConstOperation.bitOr:
+        case UnlinkedExprOperation.bitOr:
           _computeBinaryExpressionType(TokenType.BAR);
           break;
-        case UnlinkedConstOperation.bitShiftRight:
+        case UnlinkedExprOperation.bitShiftRight:
           _computeBinaryExpressionType(TokenType.GT_GT);
           break;
-        case UnlinkedConstOperation.bitShiftLeft:
+        case UnlinkedExprOperation.bitShiftLeft:
           _computeBinaryExpressionType(TokenType.LT_LT);
           break;
-        case UnlinkedConstOperation.add:
+        case UnlinkedExprOperation.add:
           _computeBinaryExpressionType(TokenType.PLUS);
           break;
-        case UnlinkedConstOperation.subtract:
+        case UnlinkedExprOperation.subtract:
           _computeBinaryExpressionType(TokenType.MINUS);
           break;
-        case UnlinkedConstOperation.multiply:
+        case UnlinkedExprOperation.multiply:
           _computeBinaryExpressionType(TokenType.STAR);
           break;
-        case UnlinkedConstOperation.divide:
+        case UnlinkedExprOperation.divide:
           _computeBinaryExpressionType(TokenType.SLASH);
           break;
-        case UnlinkedConstOperation.floorDivide:
+        case UnlinkedExprOperation.floorDivide:
           _computeBinaryExpressionType(TokenType.TILDE_SLASH);
           break;
-        case UnlinkedConstOperation.greater:
+        case UnlinkedExprOperation.greater:
           _computeBinaryExpressionType(TokenType.GT);
           break;
-        case UnlinkedConstOperation.less:
+        case UnlinkedExprOperation.less:
           _computeBinaryExpressionType(TokenType.LT);
           break;
-        case UnlinkedConstOperation.greaterEqual:
+        case UnlinkedExprOperation.greaterEqual:
           _computeBinaryExpressionType(TokenType.GT_EQ);
           break;
-        case UnlinkedConstOperation.lessEqual:
+        case UnlinkedExprOperation.lessEqual:
           _computeBinaryExpressionType(TokenType.LT_EQ);
           break;
-        case UnlinkedConstOperation.modulo:
+        case UnlinkedExprOperation.modulo:
           _computeBinaryExpressionType(TokenType.PERCENT);
           break;
-        case UnlinkedConstOperation.conditional:
+        case UnlinkedExprOperation.conditional:
           _doConditional();
           break;
-        case UnlinkedConstOperation.assignToRef:
+        case UnlinkedExprOperation.assignToRef:
           _doAssignToRef();
           break;
-        case UnlinkedConstOperation.assignToProperty:
+        case UnlinkedExprOperation.assignToProperty:
           _doAssignToProperty();
           break;
-        case UnlinkedConstOperation.assignToIndex:
+        case UnlinkedExprOperation.assignToIndex:
           _doAssignToIndex();
           break;
-        case UnlinkedConstOperation.extractIndex:
+        case UnlinkedExprOperation.extractIndex:
           _doExtractIndex();
           break;
-        case UnlinkedConstOperation.invokeMethodRef:
+        case UnlinkedExprOperation.invokeMethodRef:
           _doInvokeMethodRef();
           break;
-        case UnlinkedConstOperation.invokeMethod:
+        case UnlinkedExprOperation.invokeMethod:
           _doInvokeMethod();
           break;
-        case UnlinkedConstOperation.cascadeSectionBegin:
+        case UnlinkedExprOperation.cascadeSectionBegin:
           stack.add(stack.last);
           break;
-        case UnlinkedConstOperation.cascadeSectionEnd:
+        case UnlinkedExprOperation.cascadeSectionEnd:
           stack.removeLast();
           break;
-        case UnlinkedConstOperation.typeCast:
+        case UnlinkedExprOperation.typeCast:
           stack.removeLast();
           DartType type = _getNextTypeRef();
           stack.add(type);
           break;
-        case UnlinkedConstOperation.typeCheck:
+        case UnlinkedExprOperation.typeCheck:
           stack.removeLast();
           refPtr++;
           stack.add(typeProvider.boolType);
           break;
-        case UnlinkedConstOperation.throwException:
+        case UnlinkedExprOperation.throwException:
           stack.removeLast();
           stack.add(BottomTypeImpl.instance);
           break;
-        case UnlinkedConstOperation.pushLocalFunctionReference:
+        case UnlinkedExprOperation.pushLocalFunctionReference:
           int popCount = _getNextInt();
           assert(popCount == 0); // TODO(paulberry): handle the nonzero case.
           stack.add(function.functions[_getNextInt()].type);
           break;
-        case UnlinkedConstOperation.pushParameter:
+        case UnlinkedExprOperation.pushParameter:
           stack.add(_findParameterType(_getNextString()));
           break;
         default:
           // TODO(paulberry): implement.
           throw new UnimplementedError('$operation');
       }
     }
     assert(intPtr == unlinkedConst.ints.length);
     assert(refPtr == unlinkedConst.references.length);
     assert(strPtr == unlinkedConst.strings.length);
@@ skipping 1720 matching lines @@
   @override
   void set inheritsCovariant(bool value) {
     _inheritsCovariant = value;
   }
 
   @override
   bool get isCovariant {
     if (inheritsCovariant) {
       return true;
     }
-    for (UnlinkedConst annotation in _unlinkedParam.annotations) {
+    for (UnlinkedExpr annotation in _unlinkedParam.annotations) {
       if (annotation.operations.length == 1 &&
-          annotation.operations[0] == UnlinkedConstOperation.pushReference) {
+          annotation.operations[0] == UnlinkedExprOperation.pushReference) {
         ReferenceableElementForLink element =
             this.compilationUnit.resolveRef(annotation.references[0].reference);
         if (element is PropertyAccessorElementForLink &&
             element.name == 'checked' &&
             element.library.name == 'meta') {
           return true;
         }
       }
     }
     return false;
@@ skipping 652 matching lines @@
 
   /**
    * Collect the type inference dependencies in [unlinkedExecutable] (which
    * should be interpreted relative to [compilationUnit]) and store them in
    * [dependencies].
    */
   void collectDependencies(
       List<TypeInferenceNode> dependencies,
       UnlinkedExecutable unlinkedExecutable,
       CompilationUnitElementForLink compilationUnit) {
-    UnlinkedConst unlinkedConst = unlinkedExecutable?.bodyExpr;
+    UnlinkedExpr unlinkedConst = unlinkedExecutable?.bodyExpr;
     if (unlinkedConst == null) {
       return;
     }
     int refPtr = 0;
     int intPtr = 0;
 
-    for (UnlinkedConstOperation operation in unlinkedConst.operations) {
+    for (UnlinkedExprOperation operation in unlinkedConst.operations) {
       switch (operation) {
-        case UnlinkedConstOperation.pushInt:
+        case UnlinkedExprOperation.pushInt:
           intPtr++;
           break;
-        case UnlinkedConstOperation.pushLongInt:
+        case UnlinkedExprOperation.pushLongInt:
           int numInts = unlinkedConst.ints[intPtr++];
           intPtr += numInts;
           break;
-        case UnlinkedConstOperation.concatenate:
+        case UnlinkedExprOperation.concatenate:
           intPtr++;
           break;
-        case UnlinkedConstOperation.pushReference:
+        case UnlinkedExprOperation.pushReference:
           EntityRef ref = unlinkedConst.references[refPtr++];
           // TODO(paulberry): cache these resolved references for
           // later use by evaluate().
           TypeInferenceNode dependency =
               compilationUnit.resolveRef(ref.reference).asTypeInferenceNode;
           if (dependency != null) {
             dependencies.add(dependency);
           }
           break;
-        case UnlinkedConstOperation.invokeConstructor:
+        case UnlinkedExprOperation.invokeConstructor:
           refPtr++;
           intPtr += 2;
           break;
-        case UnlinkedConstOperation.makeUntypedList:
-        case UnlinkedConstOperation.makeUntypedMap:
+        case UnlinkedExprOperation.makeUntypedList:
+        case UnlinkedExprOperation.makeUntypedMap:
           intPtr++;
           break;
-        case UnlinkedConstOperation.makeTypedList:
+        case UnlinkedExprOperation.makeTypedList:
           refPtr++;
           intPtr++;
           break;
-        case UnlinkedConstOperation.makeTypedMap:
+        case UnlinkedExprOperation.makeTypedMap:
           refPtr += 2;
           intPtr++;
           break;
-        case UnlinkedConstOperation.assignToRef:
+        case UnlinkedExprOperation.assignToRef:
           // TODO(paulberry): if this reference refers to a variable, should it
           // be considered a type inference dependency?
           refPtr++;
           break;
-        case UnlinkedConstOperation.invokeMethodRef:
+        case UnlinkedExprOperation.invokeMethodRef:
           // TODO(paulberry): if this reference refers to a variable, should it
           // be considered a type inference dependency?
           refPtr++;
           intPtr += 2;
           int numTypeArguments = unlinkedConst.ints[intPtr++];
           refPtr += numTypeArguments;
           break;
-        case UnlinkedConstOperation.invokeMethod:
+        case UnlinkedExprOperation.invokeMethod:
           intPtr += 2;
           int numTypeArguments = unlinkedConst.ints[intPtr++];
           refPtr += numTypeArguments;
           break;
-        case UnlinkedConstOperation.typeCast:
-        case UnlinkedConstOperation.typeCheck:
+        case UnlinkedExprOperation.typeCast:
+        case UnlinkedExprOperation.typeCheck:
           refPtr++;
           break;
-        case UnlinkedConstOperation.pushLocalFunctionReference:
+        case UnlinkedExprOperation.pushLocalFunctionReference:
           int popCount = unlinkedConst.ints[intPtr++];
           assert(popCount == 0); // TODO(paulberry): handle the nonzero case.
           dependencies.add(functionElement
               .getLocalFunction(unlinkedConst.ints[intPtr++])
               .asTypeInferenceNode);
           break;
         default:
           break;
       }
     }
@@ skipping 320 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }