Variable FunctionSemanticsConst

Type Declaration

• ReadonlyargumentRoles: (
      this: void,
      ids: Iterable<NodeId>,
      graph: DataflowGraph,
      options?: ArgumentRolesOptions,
  ) => Record<NodeId, FunctionArgumentRoles>

  The roles of several definitions' formals, sharing the built-in lookups.

• Readonlycall: {
      argument: {
          mask: (names: readonly (...)[]) => number;
          names: Readonly<Record<(...), (...)>>;
          words: (props: (...) | (...)) => (...)[];
      };
      deferred: {
          forcedAt(
              this: void,
              graph: DataflowGraph,
              binding: NodeId,
              cfg: ControlFlowGraph,
          ): readonly NodeId[];
          indexOf<Info>(
              this: void,
              graph: DataflowGraph,
              idMap: AstIdMap<(...) & (...)>,
          ): NameIndex;
          link<Info>(
              this: void,
              graph: DataflowGraph,
              expr: NodeId,
              index: NameIndex,
              idMap: AstIdMap<(...) & (...)>,
              forces?: ForceSites,
          ): void;
          publish<Info>(
              this: void,
              graph: DataflowGraph,
              expr: NodeId,
              index: NameIndex,
              idMap: AstIdMap<(...) & (...)>,
              at: NodeId,
              cfg?: ControlFlowGraph<(...)>,
          ): void;
      };
      match: {
          findWithProps(
              this: void,
              args: readonly FunctionArgument[],
              signature: FnSig,
              props: number,
          ): NodeId[];
          formalsOf: <Info>(
              this: void,
              call: RFunctionCall<(...)>,
              graph: DataflowGraph,
              ctx: ReadOnlyFlowrAnalyzerContext,
          ) => (...) | (...);
          onCallAndLink(
              this: void,
              args: readonly FunctionArgument[],
              params: readonly RParameter<(...)>[],
              graph: DataflowGraph,
          ): Map<NodeId, NodeId>;
          toDefinition<Info>(
              this: void,
              call: RFunctionCall<(...) & (...)>,
              graph: DataflowGraph,
              ctx: ReadOnlyFlowrAnalyzerContext,
          ): ReadonlyMap<(...), (...)> | undefined;
          toNames<Info = object>(
              this: void,
              args: readonly PotentiallyEmptyRArgument<(...)>[],
              paramNames: readonly string[],
          ): ReadonlyMap<string, RArgument<(...)>>;
          toSpec<Targets extends NodeId = string>(
              this: void,
              args: readonly FunctionArgument[],
              params: Record<(...), (...)> | readonly (...)[],
          ): Map<Targets, (...)[]>;
      };
      nse: {
          dropResolvedMask(
              this: void,
              graph: DataflowGraph,
              id: NodeId,
              name: Identifier,
          ): MaskingCall | undefined;
          isUnquote<Info>(this: void, node: RNode<Info>, style: Unquote): boolean;
          linkMasksToData(
              this: void,
              graph: DataflowGraph,
              calls: readonly MaskingCall[],
          ): void;
          maskCandidate(
              this: void,
              vertex: DataflowGraphVertexInfo | undefined,
          ): boolean;
          maskedName(this: void, graph: DataflowGraph, id: NodeId): boolean;
          suppliedByMask(
              this: void,
              graph: DataflowGraph,
              id: NodeId,
              vertex?: DataflowGraphVertexInfo | undefined,
          ): boolean;
          unmark(
              this: void,
              graph: DataflowGraph,
              id: NodeId,
              which?: (target: NodeId) => boolean,
          ): NodeId[];
          unquoted<Info extends ParentInformation>(
              this: void,
              root: RNode<(...)> | undefined,
              style: Unquote,
          ): ReadonlySet<(...)> | undefined;
      };
      props: {
          filter(
              this: void,
              stated: StatedProps | undefined,
              selector: PropSelector,
          ): StatedProps;
          hasAll(
              this: void,
              stated: StatedProps | undefined,
              selector: PropSelector,
          ): boolean;
          hasAny(
              this: void,
              stated: StatedProps | undefined,
              selector?: PropSelector,
          ): boolean;
          isCallProp: (this: void, selector: PropSelector) => selector is number;
          isEmptyMask(this: void, mask: PropMask): boolean;
          isSemanticTag: (
              this: void,
              selector: PropSelector,
          ) => selector is SemanticCallTag;
          join(
              this: void,
              props1: StatedProps | undefined,
              props2: StatedProps | undefined,
          ): StatedProps;
          key(this: void, selector: PropSelector): string;
          labels(this: void, stated: StatedProps | undefined): string[];
          mask(this: void, names: readonly string[]): PropMask;
          names(this: void, selector: PropSelector): string[];
          words(this: void, props: number | undefined): string[];
      };
      quoted: {
          capturedBy(
              this: void,
              graph: DataflowGraph,
              id: NodeId,
          ): readonly NodeId[];
          evaluateIn: <Info>(
              this: void,
              graph: DataflowGraph,
              expr: NodeId,
              environment: REnvironmentInformation,
              idMap: AstIdMap<(...)>,
          ) => readonly (...)[];
          finalize<Info>(
              this: void,
              graph: DataflowGraph,
              idMap: AstIdMap<(...) & (...)>,
              controlFlow: () => (...) | (...),
          ): void;
          sourcesOf(
              this: void,
              graph: DataflowGraph,
              id: NodeId,
          ): readonly CapturedExpression[];
      };
      signature: {
          every: FnSig;
          forced: (this: void, sig: (...) | (...), count: number) => (...) | (...);
          layout: (this: void, sig: FnSig) => SigLayout;
          only: (this: void, index: number, name: string) => FnSig;
          posWith: (
              this: void,
              layout: SigLayout,
              count: number,
              prop: number,
          ) => (...)[];
          propAt: (
              this: void,
              __namedParameters: SigLayout,
              index: number,
          ) => number;
      };
      unsupported: {
          isUnsupportedCall(
              this: void,
              vertex: DataflowGraphVertexArgument | undefined,
              dfg: DataflowGraph,
          ): boolean;
      };
  }

  What one call of a function means: what flowR states about it, how R binds its arguments, and which of them it does not simply evaluate.

  • Readonlyargument: {
        mask: (names: readonly (...)[]) => number;
        names: Readonly<Record<(...), (...)>>;
        words: (props: (...) | (...)) => (...)[];
    }

    The same as FunctionSemantics.call.props, for one argument.

    • Readonlymask: (names: readonly (...)[]) => number

      The mask the given ArgProp member names stand for; see maskOfNames.

    • Readonlynames: Readonly<Record<(...), (...)>>

      the ArgProp bit to its name, in ascending bit order

    • Readonlywords: (props: (...) | (...)) => (...)[]

      What an argument is used for, as words; see wordsOf.

  • Readonlydeferred: {
        forcedAt(
            this: void,
            graph: DataflowGraph,
            binding: NodeId,
            cfg: ControlFlowGraph,
        ): readonly NodeId[];
        indexOf<Info>(
            this: void,
            graph: DataflowGraph,
            idMap: AstIdMap<(...) & (...)>,
        ): NameIndex;
        link<Info>(
            this: void,
            graph: DataflowGraph,
            expr: NodeId,
            index: NameIndex,
            idMap: AstIdMap<(...) & (...)>,
            forces?: ForceSites,
        ): void;
        publish<Info>(
            this: void,
            graph: DataflowGraph,
            expr: NodeId,
            index: NameIndex,
            idMap: AstIdMap<(...) & (...)>,
            at: NodeId,
            cfg?: ControlFlowGraph<(...)>,
        ): void;
    }

    The ones it evaluates at a time flowR cannot pin down.

    • forcedAt: function

      • forcedAt(
            this: void,
            graph: DataflowGraph,
            binding: NodeId,
            cfg: ControlFlowGraph,
        ): readonly NodeId[]

        The reads that may be the one forcing binding: every read of it that no other read always precedes, since an earlier read would already have forced it and cached the value.

        Parameters

        • this: void
        • graph: DataflowGraph
        • binding: NodeId
        • cfg: ControlFlowGraph

        Returns readonly NodeId[]

    • indexOf: function

      • indexOf<Info>(
            this: void,
            graph: DataflowGraph,
            idMap: AstIdMap<(...) & (...)>,
        ): NameIndex

        Where each name is bound and read, built once and shared by every deferred expression in the graph.

        Type Parameters

        • Info

        Parameters

        • this: void
        • graph: DataflowGraph
        • idMap: AstIdMap<(...) & (...)>

        Returns NameIndex

    • link: function

      • link<Info>(
            this: void,
            graph: DataflowGraph,
            expr: NodeId,
            index: NameIndex,
            idMap: AstIdMap<(...) & (...)>,
            forces?: ForceSites,
        ): void

        Links the expression rooted at expr to the bindings it may meet when it is evaluated. Given the reads that may force it, control flow rules out what no force can reach; without them every binding stays a candidate.

        Type Parameters

        • Info

        Parameters

        • this: void
        • graph: DataflowGraph
        • expr: NodeId
        • index: NameIndex
        • idMap: AstIdMap<(...) & (...)>
        • Optionalforces: ForceSites

        Returns void

    • publish: function

      • publish<Info>(
            this: void,
            graph: DataflowGraph,
            expr: NodeId,
            index: NameIndex,
            idMap: AstIdMap<(...) & (...)>,
            at: NodeId,
            cfg?: ControlFlowGraph<(...)>,
        ): void

        Links the writes an expression performs to the uses that may observe them, for a call evaluating the expression at a point control flow can pin down (eval). The reads are settled by the evaluating call itself, against the environment in effect there, so only this direction is left open.

        Type Parameters

        • Info

        Parameters

        • this: void
        • graph: DataflowGraph
        • expr: NodeId
        • index: NameIndex
        • idMap: AstIdMap<(...) & (...)>
        • at: NodeId
        • Optionalcfg: ControlFlowGraph<(...)>

        Returns void

  • Readonlymatch: {
        findWithProps(
            this: void,
            args: readonly FunctionArgument[],
            signature: FnSig,
            props: number,
        ): NodeId[];
        formalsOf: <Info>(
            this: void,
            call: RFunctionCall<(...)>,
            graph: DataflowGraph,
            ctx: ReadOnlyFlowrAnalyzerContext,
        ) => (...) | (...);
        onCallAndLink(
            this: void,
            args: readonly FunctionArgument[],
            params: readonly RParameter<(...)>[],
            graph: DataflowGraph,
        ): Map<NodeId, NodeId>;
        toDefinition<Info>(
            this: void,
            call: RFunctionCall<(...) & (...)>,
            graph: DataflowGraph,
            ctx: ReadOnlyFlowrAnalyzerContext,
        ): ReadonlyMap<(...), (...)> | undefined;
        toNames<Info = object>(
            this: void,
            args: readonly PotentiallyEmptyRArgument<(...)>[],
            paramNames: readonly string[],
        ): ReadonlyMap<string, RArgument<(...)>>;
        toSpec<Targets extends NodeId = string>(
            this: void,
            args: readonly FunctionArgument[],
            params: Record<(...), (...)> | readonly (...)[],
        ): Map<Targets, (...)[]>;
    }

    R's argument matching -- exact, then partial, then positional.

    • findWithProps: function

      • findWithProps(
            this: void,
            args: readonly FunctionArgument[],
            signature: FnSig,
            props: number,
        ): NodeId[]

        Find all arguments of a function call that have a given argument property using the function signature.

        Parameters

        • this: void
        • args: readonly FunctionArgument[]

          The function arguments as the graph holds them.

        • signature: FnSig

          The function signature whose names are the targets.

        • props: number

          The ArgProps the function arguments should have.

        Returns NodeId[]

        The value ids of the matching arguments.

    • formalsOf: <Info>(
          this: void,
          call: RFunctionCall<(...)>,
          graph: DataflowGraph,
          ctx: ReadOnlyFlowrAnalyzerContext,
      ) => (...) | (...)

      The formal names a call binds against, whichever of flowR's sources knows them; see formalsOf.

    • onCallAndLink: function

      • onCallAndLink(
            this: void,
            args: readonly FunctionArgument[],
            params: readonly RParameter<(...)>[],
            graph: DataflowGraph,
        ): Map<NodeId, NodeId>

        Binds a call's graph args to the params of the definition it calls and mutates graph, adding an EdgeType.DefinesOnCall and a EdgeType.DefinedByOnCall edge per bound pair. It is the only member here that writes anything.

        Parameters

        • this: void
        • args: readonly FunctionArgument[]

          The arguments as the graph holds them.

        • params: readonly RParameter<(...)>[]

          The parameters of the called definition, in order.

        • graph: DataflowGraph

          The graph the edges are added to.

        Returns Map<NodeId, NodeId>

        The argument id to parameter id mapping the edges were drawn for.

    • toDefinition: function

      • toDefinition<Info>(
            this: void,
            call: RFunctionCall<(...) & (...)>,
            graph: DataflowGraph,
            ctx: ReadOnlyFlowrAnalyzerContext,
        ): ReadonlyMap<(...), (...)> | undefined

        Binds a call's arguments to the formals of whatever it calls, looking the formals up itself. It takes them from the RFunctionDefinition the call resolves to in user code, and from the database signature at the version the analysis assumes otherwise (see SignatureDb). undefined when it resolves to neither, so fall back to a hardcoded list then.

        graph is what says which definition a name reaches here, because scoping, shadowing and control flow decide that and a name alone cannot. It therefore needs a finished graph rather than one under construction. Cost is one Dataflow.origin lookup plus, for a package call, decoding that one function.

        Type Parameters

        • Info

        Parameters

        • this: void
        • call: RFunctionCall<(...) & (...)>

          The call whose arguments are to be bound.

        • graph: DataflowGraph

          The finished graph the call was analyzed into.

        • ctx: ReadOnlyFlowrAnalyzerContext

          The analyzer context the database and the assumed versions come from.

        Returns ReadonlyMap<(...), (...)> | undefined

        Per formal name the argument bound to it, undefined if the formals could not be found.

    • toNames: function

      • toNames<Info = object>(
            this: void,
            args: readonly PotentiallyEmptyRArgument<(...)>[],
            paramNames: readonly string[],
        ): ReadonlyMap<string, RArgument<(...)>>

        Binds a call's AST args to the formal paramNames. An empty argument (f(1, ,3)) takes its formal but never appears here. Arguments falling to ... share that key, so only the last survives; use MatchArgs.toSpec to keep them all.

        Type Parameters

        • Info = object

        Parameters

        • this: void
        • args: readonly PotentiallyEmptyRArgument<(...)>[]

          The arguments as they stand in the normalized AST.

        • paramNames: readonly string[]

          The formals of the called function, in order.

        Returns ReadonlyMap<string, RArgument<(...)>>

        Per formal name the argument bound to it.

        See

        RFunctionCall.matchArgsToParams - the implementation, kept there to avoid a load-time import cycle.

    • toSpec: function

      • toSpec<Targets extends NodeId = string>(
            this: void,
            args: readonly FunctionArgument[],
            params: Record<(...), (...)> | readonly (...)[],
        ): Map<Targets, (...)[]>

        Binds a call's graph args against the formals, reading nothing from the graph, so it also serves a function whose parameters are not in the AST at all. Name '...' in a specification unless the function really has none, as that is what collects arguments finding no formal of their own.

        Type Parameters

        • Targets extends NodeId = string

        Parameters

        • this: void
        • args: readonly FunctionArgument[]

          The arguments as the graph holds them, see convertFnArguments.

        • params: Record<(...), (...)> | readonly (...)[]

          Formal name to the target it stands for, or a signature whose names are the targets.

        Returns Map<Targets, (...)[]>

        Per target the ids bound to it.

  • Readonlynse: {
        dropResolvedMask(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
            name: Identifier,
        ): MaskingCall | undefined;
        isUnquote<Info>(this: void, node: RNode<Info>, style: Unquote): boolean;
        linkMasksToData(
            this: void,
            graph: DataflowGraph,
            calls: readonly MaskingCall[],
        ): void;
        maskCandidate(
            this: void,
            vertex: DataflowGraphVertexInfo | undefined,
        ): boolean;
        maskedName(this: void, graph: DataflowGraph, id: NodeId): boolean;
        suppliedByMask(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
            vertex?: DataflowGraphVertexInfo | undefined,
        ): boolean;
        unmark(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
            which?: (target: NodeId) => boolean,
        ): NodeId[];
        unquoted<Info extends ParentInformation>(
            this: void,
            root: RNode<(...)> | undefined,
            style: Unquote,
        ): ReadonlySet<(...)> | undefined;
    }

    The arguments a call does not evaluate.

    • dropResolvedMask: function

      • dropResolvedMask(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
            name: Identifier,
        ): MaskingCall | undefined

        Drops the mask mark from names the caller binds to a value: while filter(d, k) is processed k has no read yet. A name bound to a function keeps its mark, as filter(d, id > 2) next to id <- function(...) still means the column. Hands back the masking call and the names it just unmarked, undefined when name does not mask at all, so linkMasksToData need not ask a second time.

        Parameters

        • this: void
        • graph: DataflowGraph
        • id: NodeId
        • name: Identifier

        Returns MaskingCall | undefined

    • isUnquote: function

      • isUnquote<Info>(this: void, node: RNode<Info>, style: Unquote): boolean

        Whether everything below node is unquoted.

        Type Parameters

        • Info

        Parameters

        • this: void
        • node: RNode<Info>
        • style: Unquote

        Returns boolean

    • linkMasksToData: function

      • linkMasksToData(
            this: void,
            graph: DataflowGraph,
            calls: readonly MaskingCall[],
        ): void

        Links every name the data masks of calls supply to the data it comes from: id in filter(df, id > 2) is a column of df, so it reads df. Run once every mark has settled, as adding the read makes suppliedByMask false for the name; a call whose first argument is masked too has no data to link against.

        Parameters

        • this: void
        • graph: DataflowGraph
        • calls: readonly MaskingCall[]

        Returns void

    • maskCandidate: function

      • maskCandidate(this: void, vertex: DataflowGraphVertexInfo | undefined): boolean

        Whether the vertex is a name a data mask may supply, which is every name appearing in the mask.

        Parameters

        • this: void
        • vertex: DataflowGraphVertexInfo | undefined

        Returns boolean

    • maskedName: function

      • maskedName(this: void, graph: DataflowGraph, id: NodeId): boolean

        Whether id is a name a data mask supplied, which the mark the masking call carries is what records. Unlike suppliedByMask this survives linkMasksToData, so ask this one after the dataflow is complete and that one while a call is still being processed.

        Parameters

        • this: void
        • graph: DataflowGraph
        • id: NodeId

        Returns boolean

    • suppliedByMask: function

      • suppliedByMask(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
            vertex?: DataflowGraphVertexInfo | undefined,
        ): boolean

        Whether id is a name the data mask supplies, i.e. a use the caller does not bind itself.

        Parameters

        • this: void
        • graph: DataflowGraph
        • id: NodeId
        • vertex: DataflowGraphVertexInfo | undefined = ...

        Returns boolean

    • unmark: function

      • unmark(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
            which?: (target: NodeId) => boolean,
        ): NodeId[]

        Drops the non-standard-evaluation mark from the outgoing edges of id that which accepts, and reports them.

        Parameters

        • this: void
        • graph: DataflowGraph
        • id: NodeId
        • which: (target: NodeId) => boolean = ...

        Returns NodeId[]

    • unquoted: function

      • unquoted<Info extends ParentInformation>(
            this: void,
            root: RNode<(...)> | undefined,
            style: Unquote,
        ): ReadonlySet<(...)> | undefined

        The ids an Unquote escape hands back to standard evaluation, the markers themselves excluded.

        Type Parameters

        • Info extends ParentInformation

        Parameters

        • this: void
        • root: RNode<(...)> | undefined
        • style: Unquote

        Returns ReadonlySet<(...)> | undefined

  • Readonlyprops: {
        filter(
            this: void,
            stated: StatedProps | undefined,
            selector: PropSelector,
        ): StatedProps;
        hasAll(
            this: void,
            stated: StatedProps | undefined,
            selector: PropSelector,
        ): boolean;
        hasAny(
            this: void,
            stated: StatedProps | undefined,
            selector?: PropSelector,
        ): boolean;
        isCallProp: (this: void, selector: PropSelector) => selector is number;
        isEmptyMask(this: void, mask: PropMask): boolean;
        isSemanticTag: (
            this: void,
            selector: PropSelector,
        ) => selector is SemanticCallTag;
        join(
            this: void,
            props1: StatedProps | undefined,
            props2: StatedProps | undefined,
        ): StatedProps;
        key(this: void, selector: PropSelector): string;
        labels(this: void, stated: StatedProps | undefined): string[];
        mask(this: void, names: readonly string[]): PropMask;
        names(this: void, selector: PropSelector): string[];
        words(this: void, props: number | undefined): string[];
    }

    What flowR states a call does (it reads a file, it asks the user, ...).

    • filter: function

      • filter(
            this: void,
            stated: StatedProps | undefined,
            selector: PropSelector,
        ): StatedProps

        Keep only the properties in the stated properties that are in the property selector.

        Parameters

        • this: void
        • stated: StatedProps | undefined
        • selector: PropSelector

        Returns StatedProps

    • hasAll: function

      • hasAll(
            this: void,
            stated: StatedProps | undefined,
            selector: PropSelector,
        ): boolean

        Whether stated properties carry every property of a selector.

        Parameters

        • this: void
        • stated: StatedProps | undefined
        • selector: PropSelector

        Returns boolean

    • hasAny: function

      • hasAny(
            this: void,
            stated: StatedProps | undefined,
            selector?: PropSelector,
        ): boolean

        Whether stated properties carry at least one property of a selector, or state anything about their behavior at all. ProvenanceProps do not count for the latter: where a definition comes from is not something it does, and a caller asking "does this state what it does" must not be answered by it.

        Parameters

        • this: void
        • stated: StatedProps | undefined
        • Optionalselector: PropSelector

        Returns boolean

    • isCallProp: (this: void, selector: PropSelector) => selector is number

      Checks whether a PropSelector is a bitfield of CallProps.

    • isEmptyMask: function

      • isEmptyMask(this: void, mask: PropMask): boolean

        Whether a PropMask names nothing at all, so filtering by it can only answer with nothing.

        Parameters

        • this: void
        • mask: PropMask

        Returns boolean

    • isSemanticTag: (this: void, selector: PropSelector) => selector is SemanticCallTag

      Checks whether a PropSelector is a SemanticCallTag.

    • join: function

      • join(
            this: void,
            props1: StatedProps | undefined,
            props2: StatedProps | undefined,
        ): StatedProps

        Joins the CallProps and SemanticCallTags of two stated properties

        Parameters

        • this: void
        • props1: StatedProps | undefined
        • props2: StatedProps | undefined

        Returns StatedProps

    • key: function

      • key(this: void, selector: PropSelector): string

        Transforms a property selector into a unique string identifier.

        Parameters

        • this: void
        • selector: PropSelector

        Returns string

    • labels: function

      • labels(this: void, stated: StatedProps | undefined): string[]

        Gets the string labels for stated properties CallPropLabels.

        Parameters

        • this: void
        • stated: StatedProps | undefined

        Returns string[]

    • mask: function

      • mask(this: void, names: readonly string[]): PropMask

        The PropMask the given CallProp/SemanticCallTag member names stand for, unknown ones ignored.

        Parameters

        • this: void
        • names: readonly string[]

        Returns PropMask

    • names: function

      • names(this: void, selector: PropSelector): string[]

        Gets the property names for a property selector.

        Parameters

        • this: void
        • selector: PropSelector

        Returns string[]

    • words: function

      • words(this: void, props: number | undefined): string[]

        The CallPropLabels words for a bare CallProps bitfield, as inferred functions carry one.

        Parameters

        • this: void
        • props: number | undefined

        Returns string[]

  • Readonlyquoted: {
        capturedBy(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
        ): readonly NodeId[];
        evaluateIn: <Info>(
            this: void,
            graph: DataflowGraph,
            expr: NodeId,
            environment: REnvironmentInformation,
            idMap: AstIdMap<(...)>,
        ) => readonly (...)[];
        finalize<Info>(
            this: void,
            graph: DataflowGraph,
            idMap: AstIdMap<(...) & (...)>,
            controlFlow: () => (...) | (...),
        ): void;
        sourcesOf(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
        ): readonly CapturedExpression[];
    }

    The expressions it quotes instead.

    • capturedBy: function

      • capturedBy(this: void, graph: DataflowGraph, id: NodeId): readonly NodeId[]

        The expressions a capturing call holds on to.

        Parameters

        • this: void
        • graph: DataflowGraph
        • id: NodeId

        Returns readonly NodeId[]

    • ReadonlyevaluateIn: <Info>(
          this: void,
          graph: DataflowGraph,
          expr: NodeId,
          environment: REnvironmentInformation,
          idMap: AstIdMap<(...)>,
      ) => readonly (...)[]

      Links every name in expr against environment and hands back what stays unresolved.

    • finalize: function

      • finalize<Info>(
            this: void,
            graph: DataflowGraph,
            idMap: AstIdMap<(...) & (...)>,
            controlFlow: () => (...) | (...),
        ): void

        The finishing pass over a complete graph: it settles what a call really evaluates, which the call itself could not know. A capture reaches the eval that forces it, a promise reaches the bindings it may be forced against, and a masked name the caller binds after all loses its mark.

        Type Parameters

        • Info

        Parameters

        • this: void
        • graph: DataflowGraph
        • idMap: AstIdMap<(...) & (...)>
        • controlFlow: () => (...) | (...)

        Returns void

    • sourcesOf: function

      • sourcesOf(
            this: void,
            graph: DataflowGraph,
            id: NodeId,
        ): readonly CapturedExpression[]

        Every expression the value at id may hold, with the call that captured it. Several is normal.

        Parameters

        • this: void
        • graph: DataflowGraph
        • id: NodeId

        Returns readonly CapturedExpression[]

  • Readonlysignature: {
        every: FnSig;
        forced: (this: void, sig: (...) | (...), count: number) => (...) | (...);
        layout: (this: void, sig: FnSig) => SigLayout;
        only: (this: void, index: number, name: string) => FnSig;
        posWith: (
            this: void,
            layout: SigLayout,
            count: number,
            prop: number,
        ) => (...)[];
        propAt: (this: void, __namedParameters: SigLayout, index: number) => number;
    }

    The formals a built-in declares.

    • Readonlyevery: FnSig

      A signature saying only that the call evaluates every argument; see ForcingEvery.

    • Readonlyforced: (this: void, sig: (...) | (...), count: number) => (...) | (...)

      Which of the first count arguments a call evaluates; see forcedArgs.

    • Readonlylayout: (this: void, sig: FnSig) => SigLayout

      The positional view of a signature; see sigLayout.

    • Readonlyonly: (this: void, index: number, name: string) => FnSig

      A signature saying only that the call evaluates one argument; see forcingOnly.

    • ReadonlyposWith: (this: void, layout: SigLayout, count: number, prop: number) => (...)[]

      The positions carrying any of the given roles; see argsWith.

    • ReadonlypropAt: (this: void, __namedParameters: SigLayout, index: number) => number

      The roles of the argument at a position; see argProp.

  • Readonlyunsupported: {
        isUnsupportedCall(
            this: void,
            vertex: DataflowGraphVertexArgument | undefined,
            dfg: DataflowGraph,
        ): boolean;
    }

    The calls that change the environment in ways flowR cannot follow.

    • isUnsupportedCall: function

      • isUnsupportedCall(
            this: void,
            vertex: DataflowGraphVertexArgument | undefined,
            dfg: DataflowGraph,
        ): boolean

        Checks whether a data flow graph vertex represents an unsupported (environment-changing) function call (e.g. eval, load, attach, rm, ...)

        Parameters

        • this: void
        • vertex: DataflowGraphVertexArgument | undefined
        • dfg: DataflowGraph

        Returns boolean

• Readonlyclasses: {
      argFor: <Info>(
          args: readonly PotentiallyEmptyRArgument<(...)>[],
          ref: ClassArgRef | undefined,
      ) => RNode<(...)> | undefined;
      declared: (graph: DataflowGraph) => Map<string, DeclaredClass>;
      isDeclaring(
          this: void,
          vertex: DataflowGraphVertexInfo | undefined,
      ): boolean;
      of: <Info>(
          config: ClassDeclarationConfig,
          args: readonly PotentiallyEmptyRArgument<(...)>[],
      ) => ClassDeclaration;
      superOf: (
          name: string,
          classes: ReadonlyMap<string, ClassDeclaration>,
      ) => string[];
      toSig: (
          classes: ReadonlyMap<string, DeclaredClass>,
          ownerOf?: (name: ...) => ...,
      ) => SigClassInfo[];
  }

  What the project declares as a class, and how those relate.

  • ReadonlyargFor: <Info>(
        args: readonly PotentiallyEmptyRArgument<(...)>[],
        ref: ClassArgRef | undefined,
    ) => RNode<(...)> | undefined

    The argument a class-declaring built-in's config names.

  • Readonlydeclared: (graph: DataflowGraph) => Map<string, DeclaredClass>

    Every class the graph declares, keyed by name.

  • isDeclaring: function

    • isDeclaring(this: void, vertex: DataflowGraphVertexInfo | undefined): boolean

      Whether the vertex is a call that declares a class; its classDecl is then set.

      Parameters

      • this: void
      • vertex: DataflowGraphVertexInfo | undefined

      Returns boolean

  • Readonlyof: <Info>(
        config: ClassDeclarationConfig,
        args: readonly PotentiallyEmptyRArgument<(...)>[],
    ) => ClassDeclaration

    The declaration a call states.

  • ReadonlysuperOf: (name: string, classes: ReadonlyMap<string, ClassDeclaration>) => string[]

    The transitive superclasses of a declared class.

  • ReadonlytoSig: (
        classes: ReadonlyMap<string, DeclaredClass>,
        ownerOf?: (name: ...) => ...,
    ) => SigClassInfo[]

    The signature-database records for a set of declared classes.

• Readonlyexceptions: (
      this: void,
      id: NodeId,
      graph: CallGraph,
      __namedParameters?: FunctionExceptionsOptions,
  ) => ExceptionsByFunction

  The exceptions a definition may raise.

• ReadonlyframeReflection: (
      this: void,
      definition: DataflowGraphVertexFunctionDefinition,
      graph: DataflowGraph,
      __namedParameters: FrameReflectionOptions,
  ) => number

  The reflective argument bits of one definition.

• ReadonlyisHigherOrder: (
      this: void,
      id: NodeId,
      graph: DataflowGraph,
      __namedParameters: HigherOrderFunctionsOptions,
  ) => boolean

  Whether one definition is higher-order, i.e. whether it calls what it is handed.

• Readonlyname: "FunctionSemantics"

• Readonlyprops: (
      this: void,
      definitions: readonly NodeId[],
      graph: DataflowGraph,
      options?: FunctionPropsOptions,
  ) => InferredFunctions

  What several definitions and their formals do.

• Readonlystrictness: (
      this: void,
      ids: Iterable<NodeId>,
      graph: DataflowGraph,
      __namedParameters?: FunctionStrictnessesOptions,
  ) => Record<NodeId, FunctionStrictness>

  The strictness of several definitions, sharing the work between them.