@eagleoutice/flowr - v2.13.14
    Preparing search index...

    Variable ResolveConst

    Resolve: {
        argument: {
            name: "argument";
            stringVector: (
                id: NodeId | RArgument<(...)> | undefined,
                info: ResolveInfo,
            ) => (...)[] | undefined;
            symbolName: (
                id: NodeId | RArgument<(...)> | undefined,
                info: ResolveInfo,
            ) => string | undefined;
            toName: (
                id: NodeId | RArgument<(...)> | undefined,
                info: ResolveInfo,
            ) => string | undefined;
            value: (
                id: NodeId | RArgument<(...)> | undefined,
                info: ResolveInfo,
            ) => string | number | boolean | (...)[] | undefined;
            vectorLength: (
                id: NodeId | RArgument<(...)> | undefined,
                info: ResolveInfo,
            ) => number | undefined;
        };
        byName: (
            id: Identifier,
            environment: REnvironmentInformation,
        ) => IdentifierDefinition[] | undefined;
        byNameAndType: (
            id: Identifier,
            environment: REnvironmentInformation,
            target: ReferenceType,
        ) => readonly IdentifierDefinition[] | undefined;
        name: "Resolve";
        toBuiltIn: (
            name: Identifier | undefined,
            environment: REnvironmentInformation,
            wantedValue: unknown,
        ) => Ternary;
        toConstants: (
            name: Identifier | undefined,
            environment: REnvironmentInformation,
        ) => ResolveResult;
        toSingleString: (
            id: NodeId | RNodeWithParent | undefined,
            info: ResolveInfo,
        ) => string | undefined;
        toValue: (
            id: NodeId | RNodeWithParent | undefined,
            environment: ResolveInfo,
        ) => ResolveResult;
    } = ...

    The helper object for resolution: from a name to the definitions it may refer to, and from a node to the value(s) it may hold. Reachable as Dataflow.resolve as well.

    Take the narrowest entry point that answers your question, they differ a lot in cost:

    • Resolve.byName walks the environment layers once and answers repeat questions from the layer's own lookup cache. Use it whenever the ReferenceType does not matter.
    • Resolve.byNameAndType additionally filters and merges the definitions of every layer it passes. Given the unknown reference type it only forwards to Resolve.byName, so ask that one directly instead.
    • Resolve.toValue and the Resolve.argument family run the evaluator on top of a resolution.

    Type Declaration

    • Readonlyargument: {
          name: "argument";
          stringVector: (
              id: NodeId | RArgument<(...)> | undefined,
              info: ResolveInfo,
          ) => (...)[] | undefined;
          symbolName: (
              id: NodeId | RArgument<(...)> | undefined,
              info: ResolveInfo,
          ) => string | undefined;
          toName: (
              id: NodeId | RArgument<(...)> | undefined,
              info: ResolveInfo,
          ) => string | undefined;
          value: (
              id: NodeId | RArgument<(...)> | undefined,
              info: ResolveInfo,
          ) => string | number | boolean | (...)[] | undefined;
          vectorLength: (
              id: NodeId | RArgument<(...)> | undefined,
              info: ResolveInfo,
          ) => number | undefined;
      }

      The same, for the arguments of a call.

      • Readonlyname: "argument"
      • ReadonlystringVector: (
            id: NodeId | RArgument<(...)> | undefined,
            info: ResolveInfo,
        ) => (...)[] | undefined

        The argument's value as a vector of strings.

      • ReadonlysymbolName: (
            id: NodeId | RArgument<(...)> | undefined,
            info: ResolveInfo,
        ) => string | undefined

        The argument's value as the name of the symbol it holds.

      • ReadonlytoName: (
            id: NodeId | RArgument<(...)> | undefined,
            info: ResolveInfo,
        ) => string | undefined

        The argument's name.

      • Readonlyvalue: (
            id: NodeId | RArgument<(...)> | undefined,
            info: ResolveInfo,
        ) => string | number | boolean | (...)[] | undefined

        The argument's value.

      • ReadonlyvectorLength: (
            id: NodeId | RArgument<(...)> | undefined,
            info: ResolveInfo,
        ) => number | undefined

        The length of the vector the argument holds.

    • ReadonlybyName: (
          id: Identifier,
          environment: REnvironmentInformation,
      ) => IdentifierDefinition[] | undefined

      Every definition the identifier may refer to, whatever its type.

    • ReadonlybyNameAndType: (
          id: Identifier,
          environment: REnvironmentInformation,
          target: ReferenceType,
      ) => readonly IdentifierDefinition[] | undefined

      The definitions the identifier may refer to that fit the wanted ReferenceType.

    • Readonlyname: "Resolve"
    • ReadonlytoBuiltIn: (
          name: Identifier | undefined,
          environment: REnvironmentInformation,
          wantedValue: unknown,
      ) => Ternary

      Whether the name always, never, or maybe refers to a built-in constant of the given value.

    • ReadonlytoConstants: (
          name: Identifier | undefined,
          environment: REnvironmentInformation,
      ) => ResolveResult

      The constant values the name resolves to.

    • ReadonlytoSingleString: (
          id: NodeId | RNodeWithParent | undefined,
          info: ResolveInfo,
      ) => string | undefined

      The single string the node resolves to, or undefined if it is not exactly one.

    • ReadonlytoValue: (
          id: NodeId | RNodeWithParent | undefined,
          environment: ResolveInfo,
      ) => ResolveResult

      The value(s) the node may hold, tracking aliases as the configuration allows.

    Settings
    Member Visibility