: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 checkCalladdEventfirstStateSharedInferenceLogWriterEvent?ShF͙GN../types/shared_type.darttype_constraint.dartgM׀؀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/v/// Representation of a single event in the inference log, with pointers to any /// events that are nested beneath it.%%%*,;:2/// Message display string.3/// List of nested events.HŌE/// Specialization of [State] used when type inferring an expression. Ǝhh/// 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.wllV/// Specialization of [State] used when generic type inference is being /// performed.ې2;KJXhgv Ð̐͐ߐf  >/// The formal type parameters whose types are being inferred.ّ/// Public API to the interface log writer. /// /// This class defines methods that the analyzer or CFE can use to instrument /// their type inference logic. The implementations are found in /// [SharedInferenceLogWriterImpl].zzE/// 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.99y/// Verifies that every call to an `enter...` method has been matched by a /// corresponding call to an `exit...` method.Jc>/// Called when type inference begins inferring an annotation. ;;/// Called when generic type inference starts collecting constraints by /// attempting to match one type schema against another.U!qp~gE/// Called when type inference begins inferring a collection element. cc>/// Called when type inference begins inferring an expression.s {z j/// Called when type inference begins inferring an AST node associated with /// extension override syntax.1 98> TSd*YY/// 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. `RR=I[Zhyxf/// Records the preliminary types chosen during either a downwards or a /// horizontal inference step."!,h/// Called when type inference is inferring an expression, and assigns the /// expression a static type.׺/// 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.D!奄/// A stack of [State] objects representing the calls that have been made to /// `enter...` methods without any matched `exit...` method. /// /// The first entry in [_stateStack] is always [_topState].өԩ̩ҩͩڀAAV/// The topmost [State] object, which recursively contains all the other /// [Event]s.MQVW[\b/// True if [dump] has been called, and therefore every call to [addEvent] /// should result in the event being immediately printed.MlE/// Gets the current state, which is the last entry in [_stateStack].!A/// Records an event by adding it to the innermost state in the [_stateStack]. /// /// If [_dumping] is `true`, then the event's message is immediately printed, /// with appropriate indentation. ,0?>2wCC23j/// 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.". 3?>ѱױز 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`.nظ noJƹ[[|!  JKٻ%%2 :9 +*- $#%%M UT%4%ON[gfA/A@A@AL ATASA/A0ABBB B%B$ABBҀBBB BBBBCCCC CCCCDDDDDE=ENENEZ EbEaE=E>FiF*F*F9 FAF@FFGGGG GGGGHvHHHHHHHHHHHHvHwHHMM(M(M3 M;M:MAMGMFMMMZN؀NNN NNNNOOOO OOOOPzQ|Q|/// 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.QQQRRERE=/// Pops the most recently pushed [State] from [_stateStack].RƀRR*/// Pushes [state] onto the [_stateStack].S S SSSSSSSSSSSSVXViViVVVVXVYXyXXXXXX;XXXyXzZZnZkZkZZZZZZZZZZZZZZZ[\́\\\]]\\^ɂ!^^^^^^_ _ ^^`aaaal/// Specialization of [Event] representing an event that might be associated /// with one or more AST nodes.dudddC/// Creates a new state object and adds it to the log via [writer].dddd,e e ee'e&e5eDeCeUe[eqeae\edemeneeffffa/// Creates a new state object representing the outermost nesting level of the /// inference log.ffff"f#f8f0f:f?f;fJfOf^fWfPfYay"bb/// 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).bdidi/// 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.fdLfwfwfdfe "{{j/// Enumeration of the possible sources of constraints that might occur during /// generic type inference.>hh/// 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.|q~r/// The source of the constraint is the analyzer's /// `GenericInferrer.constrainGenericFunctionInContext` method.)+Nߊ/// 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.-fff$/// Possible values of [State.kind]. f fffffgggg' g'g'g5g5g5gJgJgJg^g^g^ghghghgs gsgsgggU/// 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.؂܁==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`.UY`eafgk&&/// 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.9=BQJCLM׀؀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 StateKindx