anchor.diff:  // Copyright (c) 2015, 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.
  -
  -// @dart = 2.10
   
   library dart2js.js_helpers.impact;
   
  
positive.code: 
    BackendImpact get stringLiteral => stringValues;
  
    BackendImpact _catchStatement;
  
    BackendImpact get catchStatement {
      return _catchStatement ??= BackendImpact(staticUses: [
        _commonElements.exceptionUnwrapper
      ], instantiatedClasses: [
        _commonElements.jsPlainJavaScriptObjectClass,
        _commonElements.jsUnknownJavaScriptObjectClass
      ]);
    }
  
    BackendImpact _throwExpression;
  
    BackendImpact get throwExpression {
      return _throwExpression ??= BackendImpact(
          // We don't know ahead of time whether we will need the throw in a
          // statement context or an expression context, so we register both
          // here, even though we may not need the throwExpression helper.
          staticUses: [
            _commonElements.wrapExceptionHelper,
            _commonElements.throwExpressionHelper
          ]);
    }
  
    BackendImpact _lazyField;
  
    BackendImpact get lazyField {
      return _lazyField ??= BackendImpact(staticUses: [
        _commonElements.cyclicThrowHelper,
        _commonElements.throwLateFieldADI,
      ]);
    }
  
    BackendImpact _typeLiteral;
  
    BackendImpact get typeLiteral {
      return _typeLiteral ??= BackendImpact(instantiatedClasses: [
        _commonElements.typeLiteralClass
      ], staticUses: [
        _commonElements.createRuntimeType,
        _commonElements.typeLiteralMaker,
      ]);
    }
  
    BackendImpact _stackTraceInCatch;
  
    BackendImpact get stackTraceInCatch {
      return _stackTraceInCatch ??= BackendImpact(
          instantiatedClasses: [_commonElements.stackTraceHelperClass],
          staticUses: [_commonElements.traceFromException]);
    }
  
    BackendImpact _syncForIn;
  
    BackendImpact get syncForIn {
      return _syncForIn ??= BackendImpact(
          // The SSA builder recognizes certain for-in loops and can generate
          // calls to throwConcurrentModificationError.
          staticUses: [_commonElements.checkConcurrentModificationError]);
    }
  
    BackendImpact _typeVariableExpression;
  
    BackendImpact get typeVariableExpression {
      return _typeVariableExpression ??= BackendImpact(staticUses: [
        _commonElements.setArrayType,
        _commonElements.createRuntimeType
      ], otherImpacts: [
        listValues,
        getRuntimeTypeArgument,
        _needsInt('Needed for accessing a type variable literal on this.')
      ]);
    }
  
    BackendImpact _typeCheck;
  
    BackendImpact get typeCheck {
      return _typeCheck ??=
          BackendImpact(otherImpacts: [boolValues, newRtiImpact]);
    }
  
    BackendImpact _genericTypeCheck;
  
    BackendImpact get genericTypeCheck {
      return _genericTypeCheck ??= BackendImpact(staticUses: [
        // TODO(johnniwinther): Investigate why this is needed.
        _commonElements.setArrayType,
      ], otherImpacts: [
        listValues,
        getRuntimeTypeArgument,
        newRtiImpact,
      ]);
    }
  
    BackendImpact _genericIsCheck;
  
    BackendImpact get genericIsCheck {
      return _genericIsCheck ??=
          BackendImpact(otherImpacts: [intValues, newRtiImpact]);
    }
  
    BackendImpact _typeVariableTypeCheck;
  
    BackendImpact get typeVariableTypeCheck {
      return _typeVariableTypeCheck ??=
          BackendImpact(staticUses: [], otherImpacts: [newRtiImpact]);
    }
  
    BackendImpact _functionTypeCheck;
  
    BackendImpact get functionTypeCheck {
      return _functionTypeCheck ??= BackendImpact(
          staticUses: [/*helpers.functionTypeTestMetaHelper*/],
          otherImpacts: [newRtiImpact]);
    }
  
    BackendImpact _futureOrTypeCheck;
  
    BackendImpact get futureOrTypeCheck {
      return _futureOrTypeCheck ??=
          BackendImpact(staticUses: [], otherImpacts: [newRtiImpact]);
    }
  
    BackendImpact _nativeTypeCheck;
  
    BackendImpact get nativeTypeCheck {
      return _nativeTypeCheck ??= BackendImpact(staticUses: [
        // We will need to add the "$is" and "$as" properties on the
        // JavaScript object prototype, so we make sure
        // [:defineProperty:] is compiled.
        _commonElements.defineProperty
      ], otherImpacts: [
        newRtiImpact
      ]);
    }
  
    BackendImpact _closure;
  
    BackendImpact get closure {
      return _closure ??=
          BackendImpact(instantiatedClasses: [_commonElements.functionClass]);
    }
  
    BackendImpact _interceptorUse;
  
    BackendImpact get interceptorUse {
      return _interceptorUse ??= BackendImpact(
          staticUses: [
            _commonElements.getNativeInterceptorMethod
          ],
          instantiatedClasses: [
            _commonElements.jsJavaScriptObjectClass,
            _commonElements.jsLegacyJavaScriptObjectClass,
            _commonElements.jsPlainJavaScriptObjectClass,
            _commonElements.jsJavaScriptFunctionClass
          ],
          features: EnumSet<BackendFeature>.fromValues([
            BackendFeature.needToInitializeDispatchProperty,
            BackendFeature.needToInitializeIsolateAffinityTag
          ], fixed: true));
    }
  
    BackendImpact _allowInterop;
  
    BackendImpact get allowInterop => _allowInterop ??= BackendImpact(
            staticUses: [
              _commonElements.jsAllowInterop1,
              _commonElements.jsAllowInterop2,
            ],
            features: EnumSet<BackendFeature>.fromValues([
              BackendFeature.needToInitializeIsolateAffinityTag,
            ], fixed: true));
  
    BackendImpact _numClasses;
  
    BackendImpact get numClasses {
      return _numClasses ??= BackendImpact(
          // The backend will try to optimize number operations and use the
          // `iae` helper directly.
          globalUses: [_commonElements.throwIllegalArgumentException]);
    }
  
    BackendImpact _listOrStringClasses;
  
    BackendImpact get listOrStringClasses {
      return _listOrStringClasses ??= BackendImpact(
          // The backend will try to optimize array and string access and use the
          // `ioore` and `iae` _commonElements directly.
          globalUses: [
            _commonElements.throwIndexOutOfRangeException,
            _commonElements.throwIllegalArgumentException
          ]);
    }
  
    BackendImpact _functionClass;
  
    BackendImpact get functionClass {
      return _functionClass ??= BackendImpact(globalClasses: [
        _commonElements.closureClass,
        _commonElements.closureClass0Args,
        _commonElements.closureClass2Args,
      ]);
    }
  
    BackendImpact _mapClass;
  
    BackendImpact get mapClass {
      return _mapClass ??= BackendImpact(
          // The backend will use a literal list to initialize the entries
          // of the map.
          globalClasses: [
            _commonElements.listClass,
            _commonElements.mapLiteralClass
          ]);
    }
  
    BackendImpact _setClass;
  
    BackendImpact get setClass => _setClass ??= BackendImpact(globalClasses: [
          // The backend will use a literal list to initialize the entries
          // of the set.
          _commonElements.listClass,
          _commonElements.setLiteralClass,
        ]);
  
    BackendImpact _boundClosureClass;
  
    BackendImpact get boundClosureClass {
      return _boundClosureClass ??=
          BackendImpact(globalClasses: [_commonElements.boundClosureClass]);
    }
  
    BackendImpact _nativeOrExtendsClass;
  
    BackendImpact get nativeOrExtendsClass {
      return _nativeOrExtendsClass ??= BackendImpact(globalUses: [
        _commonElements.getNativeInterceptorMethod
      ], globalClasses: [
        _commonElements.jsInterceptorClass,
        _commonElements.jsJavaScriptObjectClass,
        _commonElements.jsLegacyJavaScriptObjectClass,
        _commonElements.jsPlainJavaScriptObjectClass,
        _commonElements.jsJavaScriptFunctionClass
      ]);
    }
  
    BackendImpact _mapLiteralClass;
  
    BackendImpact get mapLiteralClass {
      return _mapLiteralClass ??= BackendImpact(globalUses: [
        _commonElements.mapLiteralConstructor,
        _commonElements.mapLiteralConstructorEmpty,
        _commonElements.mapLiteralUntypedMaker,
        _commonElements.mapLiteralUntypedEmptyMaker
      ]);
    }
  
    BackendImpact _setLiteralClass;
  
    BackendImpact get setLiteralClass =>
        _setLiteralClass ??= BackendImpact(globalUses: [
          _commonElements.setLiteralConstructor,
          _commonElements.setLiteralConstructorEmpty,
          _commonElements.setLiteralUntypedMaker,
          _commonElements.setLiteralUntypedEmptyMaker,
        ]);
  
    BackendImpact _closureClass;
  
    BackendImpact get closureClass {
      return _closureClass ??=
          BackendImpact(globalUses: [_commonElements.closureFromTearOff]);
    }
  
    BackendImpact _listClasses;
  
    BackendImpact get listClasses {
      return _listClasses ??= BackendImpact(
          // Literal lists can be translated into calls to these functions:
          globalUses: [
            _commonElements.jsArrayTypedConstructor,
            _commonElements.setArrayType,
          ]);
    }
  
    BackendImpact _jsIndexingBehavior;
  
    BackendImpact get jsIndexingBehavior {
      return _jsIndexingBehavior ??= BackendImpact(
          // These two _commonElements are used by the emitter and the codegen.
          // Because we cannot enqueue elements at the time of emission,
          // we make sure they are always generated.
          globalUses: [_commonElements.isJsIndexable]);
    }
  
    BackendImpact _traceHelper;
  
    BackendImpact get traceHelper {
      return _traceHelper ??=
          BackendImpact(globalUses: [_commonElements.traceHelper]);
    }
  
    BackendImpact _assertUnreachable;
  
    BackendImpact get assertUnreachable {
      return _assertUnreachable ??=
          BackendImpact(globalUses: [_commonElements.assertUnreachableMethod]);
    }
  
    BackendImpact _runtimeTypeSupport;
  
    BackendImpact get runtimeTypeSupport {
      return _runtimeTypeSupport ??= BackendImpact(globalClasses: [
        _commonElements.listClass
      ], globalUses: [
        _commonElements.setArrayType,
      ], otherImpacts: [
        getRuntimeTypeArgument,
        computeSignature
      ]);
    }
  
    BackendImpact _deferredLoading;
  
    BackendImpact get deferredLoading {
      return _deferredLoading ??=
          BackendImpact(globalUses: [_commonElements.checkDeferredIsLoaded],
              // Also register the types of the arguments passed to this method.
              globalClasses: [_commonElements.stringClass]);
    }
  
    BackendImpact _noSuchMethodSupport;
  
    BackendImpact get noSuchMethodSupport {
      return _noSuchMethodSupport ??= BackendImpact(globalUses: [
        _commonElements.createInvocationMirror,
        _commonElements.createUnmangledInvocationMirror
      ], dynamicUses: [
        Selectors.noSuchMethod_
      ]);
    }
  
    BackendImpact _loadLibrary;
  
    /// Backend impact for accessing a `loadLibrary` function on a deferred
    /// prefix.
    BackendImpact get loadLibrary {
      return _loadLibrary ??= BackendImpact(globalUses: [
        _commonElements.loadDeferredLibrary,
      ]);
    }
  
    BackendImpact _memberClosure;
  
    /// Backend impact for performing member closurization.
    BackendImpact get memberClosure {
      return _memberClosure ??=
          BackendImpact(globalClasses: [_commonElements.boundClosureClass]);
    }
  
    BackendImpact _staticClosure;
  
    /// Backend impact for performing closurization of a top-level or static
    /// function.
    BackendImpact get staticClosure {
      return _staticClosure ??=
          BackendImpact(globalClasses: [_commonElements.closureClass]);
    }
  
    final Map<int, BackendImpact> _genericInstantiation = {};
  
    BackendImpact getGenericInstantiation(int typeArgumentCount) =>
        _genericInstantiation[typeArgumentCount] ??= BackendImpact(staticUses: [
          _commonElements.getInstantiateFunction(typeArgumentCount),
          _commonElements.instantiatedGenericFunctionTypeNewRti,
          _commonElements.closureFunctionType,
        ], instantiatedClasses: [
          _commonElements.getInstantiationClass(typeArgumentCount),
        ]);
  
    /// Backend impact for --experiment-new-rti.
    BackendImpact _newRtiImpact;
  
    // TODO(sra): Split into refined impacts.
    BackendImpact get newRtiImpact =>
        _newRtiImpact ??= BackendImpact(staticUses: [
          _commonElements.findType,
          _commonElements.instanceType,
          _commonElements.arrayInstanceType,
          _commonElements.simpleInstanceType,
          _commonElements.rtiEvalMethod,
          _commonElements.rtiBindMethod,
          _commonElements.installSpecializedIsTest,
          _commonElements.generalIsTestImplementation,
          _commonElements.generalAsCheckImplementation,
          _commonElements.installSpecializedAsCheck,
          _commonElements.generalNullableIsTestImplementation,
          _commonElements.generalNullableAsCheckImplementation,
          // Specialized checks.
          _commonElements.specializedIsBool,
          _commonElements.specializedAsBool,
          _commonElements.specializedAsBoolLegacy,
          _commonElements.specializedAsBoolNullable,
          // no specializedIsDouble.
          _commonElements.specializedAsDouble,
          _commonElements.specializedAsDoubleLegacy,
          _commonElements.specializedAsDoubleNullable,
          _commonElements.specializedIsInt,
          _commonElements.specializedAsInt,
          _commonElements.specializedAsIntLegacy,
          _commonElements.specializedAsIntNullable,
          _commonElements.specializedIsNum,
          _commonElements.specializedAsNum,
          _commonElements.specializedAsNumLegacy,
          _commonElements.specializedAsNumNullable,
          _commonElements.specializedIsString,
          _commonElements.specializedAsString,
          _commonElements.specializedAsStringLegacy,
          _commonElements.specializedAsStringNullable,
          _commonElements.specializedIsTop,
          _commonElements.specializedAsTop,
          _commonElements.specializedIsObject,
          _commonElements.specializedAsObject,
        ], globalClasses: [
          _commonElements.closureClass, // instanceOrFunctionType uses this.
        ]);
  
    BackendImpact _rtiAddRules;
  
    // TODO(fishythefish): Split into refined impacts.
    BackendImpact get rtiAddRules => _rtiAddRules ??= BackendImpact(globalUses: [
          _commonElements.rtiAddRulesMethod,
          _commonElements.rtiAddErasedTypesMethod,
          if (_options.enableVariance)
            _commonElements.rtiAddTypeParameterVariancesMethod,
        ], otherImpacts: [
          _needsString('Needed to encode the new RTI ruleset.')
        ]);
  
    BackendImpact _lateFieldReadCheck;
  
    BackendImpact get lateFieldReadCheck =>
        _lateFieldReadCheck ??= BackendImpact(globalUses: [
          _commonElements.throwUnnamedLateFieldNI,
          _commonElements.throwLateFieldNI,
        ]);
  
    BackendImpact _lateFieldWriteOnceCheck;
  
    BackendImpact get lateFieldWriteOnceCheck =>
        _lateFieldWriteOnceCheck ??= BackendImpact(globalUses: [
          _commonElements.throwUnnamedLateFieldAI,
          _commonElements.throwLateFieldAI,
        ]);
  
    BackendImpact _lateFieldInitializeOnceCheck;
  
    BackendImpact get lateFieldInitializeOnceCheck =>
        _lateFieldInitializeOnceCheck ??= BackendImpact(globalUses: [
          _commonElements.throwUnnamedLateFieldADI,
          _commonElements.throwLateFieldADI,
        ]);
  }
  
negative.code:     return stringValues;
    }
  
    late final BackendImpact assertWithoutMessage = BackendImpact(
      staticUses: [_commonElements.assertHelper],
    );
  
    late final BackendImpact assertWithMessage = BackendImpact(
      staticUses: [_commonElements.assertTest, _commonElements.assertThrow],
    );
  
    late final BackendImpact asyncForIn = BackendImpact(
      staticUses: [_commonElements.streamIteratorConstructor],
    );
  
    late final BackendImpact stringInterpolation = BackendImpact(
      dynamicUses: [Selectors.toString_],
      staticUses: [_commonElements.stringInterpolationHelper],
      otherImpacts: [_needsString('Strings are created.')],
    );
  
    late final BackendImpact stringJuxtaposition =
        _needsString('String.concat is used.');
  
    BackendImpact get nullLiteral => nullValue;
  
  