:argumentgenericFunctionInContext returnType descriptiontoStringmessage subEvents typeRecorded typeFormalsassertGenericInferenceState assertIdleenterAnnotationenterConstraintGeneration enterElemententerExpressionenterExtensionOverride'enterFunctionExpressionInvocationTargetenterGenericInference enterLValue enterPatternenterStatementexitAnnotationexitConstraintGeneration exitElementexitExpressionexitExtensionOverrideexitGenericInference exitLValue exitPattern exitStatementrecordExpressionRewriterecordExpressionWithNoTyperecordGeneratedConstraintrecordLookupResultrecordPreliminaryTypesrecordStaticType _stateStack _topState_dumpingstateaddEvent checkCalldumpfailpopState pushStatekindnodeSet annotationcollectionElementconstraintGeneration expressionextensionOverridegenericInferencelValuepattern statementtop _descriptionLengthThreshold_eventTruncationThreshold_rewrittenExpressions_truncationEventdescribeConstraintGenerationSourceEventExpressionStateGenericInferenceStateSharedInferenceLogWriterSharedInferenceLogWriterImplState StateKindPintrecordExpressionRewriteExpandoboolmessageStringObjecttoString replaceAlllength substringe runtimeType descriptionoverrideListrecordStaticTyperecordExpressionWithNoTypekind expressiongenericInferencenodeSetparent inProgressvoid SharedTypeSharedTypeParameterreanalyzeAsRValue newExpression oldExpressionMergedTypeConstraint_topaddlast subEventsprint removeRangetop expectedNode expectedKindmethod argumentsnamedArgumentsMapargumentMapEntryentrieskeyvaluejoinany identicalnodesubEvent annotationwriterconstraintGenerationcollectionElementextensionOverride typeFormal displayName typeFormalslValuepattern statement typeRecordedabortedfailed finalTypesiNever StateError removeLaststatetypetarget methodName checkCalladdEventfirstStateSharedInferenceLogWriterEventh~S?MUKbI../types/shared_type.darttype_constraint.dartDgM׀؀SρBۂ܃+O 7jkTUąHzÆӆ Zv)fKL/0|,./ҋ"#EGHEՎ&a~ Wf4Rp(,zߒ_?EՓLs2GH4x\abRߚ,-x Kopۛܜ+NO*+z˝̝5PҞ9ԠBCX^áɢaM|"b#Cbѥ)*wԦ֦ק [Ш o3rxשت#3_`&FJK b2qέ M%+/0RRRuRRRRRRSS8S_SeSSSSSSTT,T_TTTUU/UjUUVVVKVQVUVVVbVVVVWWFWTWWWXMXSXrXvXwXXYYYDYpYYZ ZSZWZXZdZZZZ[[[;[U[y[[[[[\*\=\\\\\]]]G]c]]^^U^\^t^^^^__ _D_k___``S`q``````a;a[awaaab<bbbbbc5c}cddSdrdsdddee/eMeueeeeef f(fBfafbfnffffffg g%g3gHg\gfgqg~gg%*,,:%%ዶ2/// Message display string.3/// List of nested events.//v/// Representation of a single event in the inference log, with pointers to any /// events that are nested beneath it.Ȏ whh/// Whether [SharedInferenceLogWriterImpl.recordStaticType] or /// [SharedInferenceLogWriterImpl.recordExpressionWithNoType] has been called /// for the expression represented by this [State] object. /// /// The inference log infrastructure uses this boolean to verify that each /// expression that undergoes type inference either receives a static type, or /// is determined by analysis to not need a static type.HHE/// Specialization of [State] used when type inferring an expression.2;;JXXgvv Ð̐͐ߐ f >/// The formal type parameters whose types are being inferred.lV/// Specialization of [State] used when generic type inference is being /// performed.zE/// If [inProgress] is `true`, verifies that generic type inference is in /// progress; otherwise, verifies that generic type inference is not in /// progress. /// /// This method is used by the analyzer to validate certain assumptions about /// the state of type inference, for example: /// /// - That in methods that are passed a nullable reference to /// `GenericInferrer`, a non-null value is passed in if and only if generic /// type inference is in progress. /// /// - That when the user supplies explicit type arguments, generic type /// inference does not take place.9y/// Verifies that every call to an `enter...` method has been matched by a /// corresponding call to an `exit...` method. JJc>/// Called when type inference begins inferring an annotation.UU!p~~;/// Called when generic type inference starts collecting constraints by /// attempting to match one type schema against another. gE/// Called when type inference begins inferring a collection element.ss z c>/// Called when type inference begins inferring an expression.11 8>> Sj/// Called when type inference begins inferring an AST node associated with /// extension override syntax. dd*Y/// Called when type inference has discovered that a construct that uses /// method invocation syntax (e.g. `x.f()`) is actually an invocation of a /// getter. /// /// [node] is the AST node for the rewritten getter (e.g. `x.f`).% !./// Called when generic type inference begins. //{X/// Called when type inference begins inferring the left hand side of an /// assignment. \:/// Called when type inference begins inferring a pattern.aa h`R,2322wC".33>ѱױز j/// Performs checks on [state], and calls [fail] if those checks fail. /// /// If [expectedNode] is not `null`, then [state] is checked to see if its /// [State.nodeSet] contains [expectedNode]. /// /// If [expectedKind] is not `null`, then [state] is checked to see if its /// [State.kind] matches [expectedKind]. /// /// If a check fails, then [method], [arguments], and [namedArguments] are /// used to describe the circumstances of the failure.OҀ/// Begins dumping the inference log to standard output, if dumping hasn't /// been begun already. /// /// Dumping continues for the remainder of the lifetime of `this`. nonn||!  JKJJ[22 9% * #-MM T%44%N[[f%ALAL ASA/A0A/A/A@BB B$ABAABBB BBBBBҀBCC CCCCCCDDDDDEZEZ EaE=E>E=E=ENF9F9 F@FFFFiF*GG GGGGGGHHHHHHHHHHvHwHHHvHvHM3M3 M:MAMAMFMMMZMMM(NN NNNNN؀NOO OOOOOOQQQPPzQ|/// Called when a check performed by the inference logging mechanism fails. /// /// The contents of the inference log are dumped to standard output, including /// an event showing the failure [message], and then an exception is thrown.RRRE=/// Pops the most recently pushed [State] from [_stateStack].SS SRRƀR*/// Pushes [state] onto the [_stateStack].SSSSSSSSSSSVVVVXVYVXVXViXXXXX;XXyXzXyXyXZZZZZZZZZZZZZZZ[ZZZZnZk\\]\\\\́\^^^^^_ ^^^^ɂ!^צ׺/// Implementation of the interface log writer. /// /// This class provides the implementation of [SharedInferenceLogWriter], along /// with additional helper methods. /// /// The helper methods are public so that the analyzer and CFE can call them /// from classes derived from [SharedInferenceLogWriterImpl], but these methods /// are not exposed in [SharedInferenceLogWriter] so that they won't be called /// accidentally on their own.ddddddd,e eee&e5e5eCeUe[eqeae\edemenduduC/// Creates a new state object and adds it to the log via [writer].effffff"f#f8f0f:f?f;fJfOf^fWfPfYeefa/// Creates a new state object representing the outermost nesting level of the /// inference log.bay"b/// The kind of state object. /// /// This allows [SharedInferenceLogWriterImpl.checkCall] to quickly check that /// certain operations are only performed when expected (e.g. a type should /// only be recorded when performing type inference on an expression).dibdi/// A list of all the AST nodes for which this state is valid. /// /// Typically this list will have a single value (the node that was passed to /// the corresponding `enter...` method). But if a node is rewritten, /// additional values will be added to the list. This makes it possible for /// `exit...` calls to verify that they match the appropriate corresponding /// `enter...` calls, while being tolerant of rewrites.fdfefdfdLfw``aal/// Specialization of [Event] representing an event that might be associated /// with one or more AST nodes.ފ>p|q~h/// The source of the constraint is the static type of an argument to the /// method whose type is being inferred, being matched against the /// corresponding parameter in the method's function type.H)+r/// The source of the constraint is the analyzer's /// `GenericInferrer.constrainGenericFunctionInContext` method.,NN/// The source of the constraint is the context of the invocation whose /// type is being inferred, being matched against the return type in function /// or method being invoked.2h/// A text description of this constraint generation source, suitable for /// including in log messages.- "{j/// Enumeration of the possible sources of constraints that might occur during /// generic type inference. ff ffffgggg'g' g'g5g5g5gJgJgJg^g^g^ghghghgsgs gsgggfff$/// Possible values of [State.kind]. UU/// Converts [o] to a string in a way that: /// - Shows the runtime type, /// - Is tolerant of exceptions, and /// - Limits the length of the result.{]a]6/// Maximum length for strings returned by [describe].؂Y1/// Maximum number of events stored in the inference log at each nesting level /// while not dumping output. /// /// If more events than this occur at any given nesting level, older events will /// be discarded and replaced with [_truncationEvent], to avoid the inference /// log using up too much memory.UY`eafg=܁=Z/// Expando storing a value `true` for each expression that has been passed to /// the `oldExpression` argument of /// [SharedInferenceLogWriterImpl.recordExpressionRewrite]. /// /// This is used as a check to make sure that /// [SharedInferenceLogWriterImpl.recordExpressionRewrite] isn't called more /// than once for any given `oldExpression`.9=BQJCL&k&/// When more than [_eventTruncationThreshold] events occur at any given nesting /// level, this event is used as a placeholder to take the place of any /// discarded events.M׀؀SρBۂ܃+O 7jkTUąHzÆӆ Zv)fKL/0|,./ҋ"#EGHEՎ&a~ Wf4Rp(,zߒ_?EՓLs2GH4x\abRߚ,-x Kopۛܜ+NO*+z˝̝5PҞ9ԠBCX^áɢaM|"b#Cbѥ)*wԦ֦ק [Ш o3rxשت#3_`&FJK b2qέ M%+/0RRRuRRRRRRSS8S_SeSSSSSSTT,T_TTTUU/UjUUVVVKVQVUVVVbVVVVWWFWTWWWXMXSXrXvXwXXYYYDYpYYZ ZSZWZXZdZZZZ[[[;[U[y[[[[[\*\=\\\\\]]]G]c]]^^U^\^t^^^^__ _D_k___``S`q``````a;a[awaaab<bbbbbc5c}cddSdrdsdddee/eMeueeeeef f(fBfafbfnffffffg g%g3gHg\gfgqg~gg _descriptionLengthThreshold_eventTruncationThreshold_rewrittenExpressions_truncationEventdescribeConstraintGenerationSourceEventExpressionStateGenericInferenceStateSharedInferenceLogWriterSharedInferenceLogWriterImplState StateKindN