JetBrains.ReSharper.Plugins.FSharp.Psi Means the accessor has a C#-incompatible signature. todo: find a better name Is compiled to a .NET literal

Common interface for expression types that may have a `!` variant

Indicates whether the expression has the `!` in the keyword. For example `let!` or `match!`.

In simple cases uses syntax to determine whether this pattern uses an existing symbol or introduces a new one. In complex cases uses resolve via FCS. Workaround for pseudo-resolve during parts creation needing to look at qualified names like CompilationRepresentationFlags.ModuleSuffix. List of arguments aligned with their matching parameter. e.g. index #2 is the argument that matches with param #2 on the invoked reference. A null element at a given index means there is no argument matching that parameter. Remove compiled name if present and update all references. Change the name seen by F# source only and update F# references. Change the name seen by other languages and update non-F# references. May take long time due to waiting for FCS. Symbol is cached in declaration. Name used in F# source code. Name used in compiled assemblies. Documents are currently used in F# files parsing for getting line index info. This property is only set in FSharpElementFactory to override the document for the context source file while opening chameleon expressions. Returns associated '=' token, possibly from containing type declaration A workaround for getting a declared element for binding in features like Find Usages results and file member navigation where we're looking for containing type member. May take long time due to waiting for FCS. May take long time due to waiting for FCS.

Represents a kind of F#-specific extension member.

F# type extension member.

Qualified source name Workaround for providing IVT attributes until attributes can be resolved in a better/faster way. * abstract types (i.e., no representation in a signature file) * units of measure Most F# elements are considered partial as an easy way to support signatures, intrinsic type extensions and virtual members. Base type for F# symbols compiled as properties. Union case or exception field compiled to a property. Record field compiled to a property. Not fully correct, since type parameter count doesn't fully follow logic used for source elements. Current implementation allows good enough results in FSharpResolveUtil.resolvesToAssociatedModule. Doesn't take opened modules into account, only checks if qualifiers are required by containing type or syntax.

Usual continuous indent rule: Start next line Exception resume continuous indent // returning to the start level next line after resume This (F#) continuous indent rule Start next line Exception resume continuous indent // continuing from last line before exception next line after resume Example: `|` in or-patterns: match () with | a | b -> ()

Index of the parameter in F# curried parameter groups. The compiled parameters may be inferred by the compiler, so a semantic parameter may differ from the syntax one. When `ParameterIndex` is `null`, it means it's the only parameter in the group. This is done to help recognize cases when one syntax parameter produces multiple semantic ones. Index of the parameter in F# curried parameter groups. The compiled parameters may be inferred by the compiler, so a semantic parameter may differ from the syntax one. When `ParameterIndex` is `null`, it means it's the only parameter in the group. This is done to help recognize cases when one syntax parameter produces multiple semantic ones. Same-source-named type element defined in the same namespace group, forcing the module to have `Module` suffix. Some declared elements created from patterns cannot be made mutable, e.g. function parameters or patterns in match clauses.

State contract: 5 bits - yy_lexical_state (should be le 31) 27 bits - paren depth in type app state In invalid state all bits are 1

Does not reuse existing file resolve results, does complete lookup by name. Maps FSharpSymbol elements (produced by FSharp.Compiler.Service) to declared elements.

Map FSharpType elements (as seen by FSharp.Compiler.Service) to IType types.

Has the 'name = expr' form IBinaryAppExpr used exactly as a named argument (without taking into account resolve) Checks exactly for ILambdaExpr Checks if an identifier is escaped, like in ``foo bar``. Synthetic FCS symbols may have escaped empty names, like ````.