perf: big perf improvement for call link res (closes #2128)

EagleoutIce · EagleoutIce · commit c7b7c22b0566 · 2025-12-29T18:06:31.000+01:00
diff --git a/src/dataflow/environments/built-in-config.ts b/src/dataflow/environments/built-in-config.ts
@@ -28,7 +28,7 @@ export interface BuiltInConstantDefinition<Value> extends BaseBuiltInDefinition
 export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappingName> extends BaseBuiltInDefinition {
     readonly type:      'function';
     readonly processor: BuiltInProcessor;
-    readonly config?:   ConfigOfBuiltInMappingName<BuiltInProcessor>;
+    readonly config?:   ConfigOfBuiltInMappingName<BuiltInProcessor> & { libFn?: boolean };
 	readonly evalHandler?: string
 }
 
@@ -39,15 +39,14 @@ export interface BuiltInFunctionDefinition<BuiltInProcessor extends BuiltInMappi
 export interface BuiltInReplacementDefinition extends BaseBuiltInDefinition {
     readonly type:     'replacement';
     readonly suffixes: ('<<-' | '<-')[];
-	readonly config:      { readIndices: boolean }
+    readonly config:   { readIndices: boolean }
 }
 
-/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-export type BuiltInDefinition = BuiltInConstantDefinition<any> | BuiltInFunctionDefinition<any> | BuiltInReplacementDefinition;
+export type BuiltInDefinition<T extends BuiltInMappingName = BuiltInMappingName> = BuiltInConstantDefinition<unknown> | BuiltInFunctionDefinition<T> | BuiltInReplacementDefinition;
 /**
  * @see DefaultBuiltinConfig
  */
-export type BuiltInDefinitions = BuiltInDefinition[];
+export type BuiltInDefinitions<Keys extends BuiltInMappingName[] = BuiltInMappingName[]> = [...{ [ K in keyof Keys]: BuiltInDefinition<Keys[K]> }]
 
 
 /**
@@ -56,7 +55,7 @@ export type BuiltInDefinitions = BuiltInDefinition[];
 export function getDefaultBuiltInDefinitions(): BuiltIns {
 	const builtIns = new BuiltIns();
 	for(const definition of DefaultBuiltinConfig) {
-		builtIns.registerBuiltInDefinition(definition);
+		builtIns.registerBuiltInDefinition(definition as BuiltInDefinition);
 	}
 	return builtIns;
 }
@@ -66,7 +65,7 @@ export function getDefaultBuiltInDefinitions(): BuiltIns {
  * @param definitions - the list of built-in definitions
  * @param loadDefaults - whether to first add the {@link DefaultBuiltinConfig} before the given {@link definitions}
  */
-export function getBuiltInDefinitions(definitions: BuiltInDefinitions, loadDefaults: boolean | undefined): BuiltIns {
+export function getBuiltInDefinitions<Keys extends BuiltInMappingName[]>(definitions: BuiltInDefinitions<Keys>, loadDefaults: boolean | undefined): BuiltIns {
 	let builtIns = new BuiltIns();
 
 	if(loadDefaults) {
diff --git a/src/dataflow/environments/built-in.ts b/src/dataflow/environments/built-in.ts
@@ -81,7 +81,7 @@ export interface BuiltInIdentifierDefinition extends IdentifierReference {
 	type:      ReferenceType.BuiltInFunction
 	definedAt: BuiltIn
 	processor: BuiltInIdentifierProcessor
-	config?:   object
+	config?:   ConfigOfBuiltInMappingName<BuiltInMappingName> & { libFn?: boolean }
 }
 
 export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierReference {
diff --git a/src/dataflow/environments/default-builtin-config.ts b/src/dataflow/environments/default-builtin-config.ts
@@ -99,7 +99,7 @@ function toRegex(n: readonly string[]): RegExp {
 /**
  * Contains the built-in definitions recognized by flowR
  */
-export const DefaultBuiltinConfig: BuiltInDefinitions = [
+export const DefaultBuiltinConfig = [
 	{ type: 'constant', names: ['NULL', 'NA', 'NaN', 'NA_integer_', 'NA_real_', 'NA_complex_', 'NA_character_'],  value: null,  assumePrimitive: true },
 	{ type: 'constant', names: ['TRUE', 'T'],   value: true,  assumePrimitive: true },
 	{ type: 'constant', names: ['FALSE', 'F'],  value: false, assumePrimitive: true },
@@ -186,6 +186,7 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 		names:     GgPlotAddons,
 		processor: 'builtin:default',
 		config:    {
+			libFn:                 true,
 			forceArgs:             'all',
 			hasUnknownSideEffects: {
 				type:     'link-to-last-call',
@@ -197,6 +198,7 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 		names:     TinyPlotAddons,
 		processor: 'builtin:default',
 		config:    {
+			libFn:                 true,
 			forceArgs:             'all',
 			hasUnknownSideEffects: {
 				type:     'link-to-last-call',
@@ -208,6 +210,7 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 		names:     ['image_write', 'image_capture', 'dev.capture', 'dev.off'],
 		processor: 'builtin:default',
 		config:    {
+			libFn:                 true,
 			forceArgs:             'all',
 			hasUnknownSideEffects: {
 				type:     'link-to-last-call',
@@ -217,14 +220,17 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 	{ type: 'function', names: ['('],                                          processor: 'builtin:default',             config: { returnsNthArgument: 0 },                                                     assumePrimitive: true  },
 	{ type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'],      processor: 'builtin:default',             config: { hasUnknownSideEffects: true, forceArgs: [true] },                            assumePrimitive: false },
 	{ type: 'function', names: ['body', 'formals', 'environment'],             processor: 'builtin:default',             config: { hasUnknownSideEffects: true, forceArgs: [true] },                            assumePrimitive: true },
-	{ type:      'function', names:     ['.Call', '.External', '.C', '.Fortran'],       processor: 'builtin:default',             config:    { hasUnknownSideEffects: true, forceArgs:             [true],
-		treatAsFnCall:         {
-			'.Call':     ['.NAME'],
-			'.External': ['.NAME'],
-			'.C':        ['.NAME'],
-			'.Fortran':  ['.NAME']
-		}
-	},                            assumePrimitive: true },
+	{ type:      'function',
+		names:     ['.Call', '.External', '.C', '.Fortran'],
+		processor: 'builtin:default',
+		config:    { hasUnknownSideEffects: true, forceArgs:             [true],
+			treatAsFnCall:         {
+				'.Call':     ['.NAME'],
+				'.External': ['.NAME'],
+				'.C':        ['.NAME'],
+				'.Fortran':  ['.NAME']
+			}
+		},                            assumePrimitive: true },
 	{ type: 'function', names: ['eval'],                                       processor: 'builtin:eval',                config: { includeFunctionCall: true },                                                 assumePrimitive: true },
 	{ type: 'function', names: ['cat'],                                        processor: 'builtin:default',             config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } },                                                         assumePrimitive: false },
 	{ type: 'function', names: ['switch'],                                     processor: 'builtin:default',             config: { forceArgs: [true] },                                                         assumePrimitive: false },
@@ -257,8 +263,8 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 	{ type: 'function', names: ['while'],                                      processor: 'builtin:while-loop',          config: {},                                                                            assumePrimitive: true  },
 	{ type: 'function', names: ['do.call'],                                    processor: 'builtin:apply',               config: { indexOfFunction: 0, unquoteFunction: true },                                 assumePrimitive: true  },
 	{ type: 'function', names: ['.Primitive', '.Internal'],                    processor: 'builtin:apply',               config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true  },
-	{ type: 'function', names: ['interference'],                               processor: 'builtin:apply',               config: { unquoteFunction: true, nameOfFunctionArgument: 'propensity_integrand' },     assumePrimitive: false },
-	{ type: 'function', names: ['ddply'],                                      processor: 'builtin:apply',               config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun' }, assumePrimitive: false },
+	{ type: 'function', names: ['interference'],                               processor: 'builtin:apply',               config: { unquoteFunction: true, nameOfFunctionArgument: 'propensity_integrand', libFn: true },     assumePrimitive: false },
+	{ type: 'function', names: ['ddply'],                                      processor: 'builtin:apply',               config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun', libFn: true }, assumePrimitive: false },
 	{ type: 'function', names: ['list'],                                       processor: 'builtin:list',                config: {},                                                                            assumePrimitive: true  },
 	{ type: 'function', names: ['c'],                                          processor: 'builtin:vector',              config: {},                                                                            assumePrimitive: true, evalHandler: 'builtin:c'  },
 	{
@@ -275,11 +281,9 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 	{
 		type:  'function',
 		names: [
-			'on.exit', 'sys.on.exit', 'par', 'tpar', 'sink', 'tinytheme', 'theme_set',
+			'on.exit', 'sys.on.exit', 'par', 'tpar', 'sink',
 			/* library and require is handled above */
 			'requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace',
-			/* downloader and installer functions (R, devtools, BiocManager) */
-			'library.dynam', 'install.packages','install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages',
 			/* weird env attachments */
 			'attach', 'unname', 'data',
 			/* file creation/removal */
@@ -289,6 +293,17 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 		config:          { hasUnknownSideEffects: true },
 		assumePrimitive: false
 	},
+	{
+		type:  'function',
+		names: [
+			'tinytheme', 'theme_set',
+			/* downloader and installer functions (R, devtools, BiocManager) */
+			'library.dynam', 'install.packages','install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages',
+		],
+		processor:       'builtin:default',
+		config:          { hasUnknownSideEffects: true, libFn: true },
+		assumePrimitive: false
+	},
 	/* they are all mapped to `<-` but we separate super assignments */
 	{
 		type:     'replacement',
@@ -306,17 +321,17 @@ export const DefaultBuiltinConfig: BuiltInDefinitions = [
 			readIndices: false
 		}
 	}
-];
+] as const satisfies BuiltInDefinitions;
 
 
 /**
- *
+ * Expensive and naive lookup of the default processor for a built-in function name
  */
 export function getDefaultProcessor(name: string): BuiltInMappingName | 'unnamed' | undefined {
 	if(name.startsWith(UnnamedFunctionCallPrefix)) {
 		return 'unnamed';
 	}
-	const fn = DefaultBuiltinConfig.find(def => (def.names.includes(name) && def.type !== 'constant')
+	const fn = DefaultBuiltinConfig.find(def => ((def.names as string[]).includes(name) && def.type !== 'constant')
 	|| (def.type === 'replacement' && def.suffixes.flatMap(d => def.names.map(n => `${n}${d}`)).includes(name))
 	) as BuiltInFunctionDefinition<'builtin:default'> | BuiltInReplacementDefinition | undefined;
 	return fn?.type === 'replacement' ? 'builtin:replacement' : fn?.processor as BuiltInMappingName;
diff --git a/src/dataflow/environments/environment.ts b/src/dataflow/environments/environment.ts
@@ -155,8 +155,9 @@ export class Environment implements IEnvironment {
 				// we need to make a copy to avoid side effects for old reference in other environments
 				const updatedOld: IdentifierDefinition[] = old?.slice() ?? [];
 				for(const v of values) {
-					const index = updatedOld.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
-					if(index >= 0) {
+					const { nodeId, definedAt } = v;
+					const index = updatedOld.find(o => o.nodeId === nodeId && o.definedAt === definedAt);
+					if(index) {
 						continue;
 					}
 					if(applyCds === undefined) {
diff --git a/src/dataflow/graph/dataflowgraph-builder.ts b/src/dataflow/graph/dataflowgraph-builder.ts
@@ -413,7 +413,7 @@ export class DataflowGraphBuilder<
  *
  */
 export function getBuiltInSideEffect(name: string): LinkTo<RegExp> | undefined {
-	const got = DefaultBuiltinConfig.find(e => e.names.includes(name));
+	const got = DefaultBuiltinConfig.find(e => (e.names as string[]).includes(name));
 	if(got?.type !== 'function') {
 		return undefined;
 	}
diff --git a/src/dataflow/internal/linker.ts b/src/dataflow/internal/linker.ts
@@ -1,5 +1,5 @@
 import { DefaultMap } from '../../util/collections/defaultmap';
-import { guard, isNotUndefined } from '../../util/assert';
+import { isNotUndefined } from '../../util/assert';
 import { expensiveTrace, log } from '../../util/log';
 import { type NodeId, recoverName } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type IdentifierReference, isReferenceType, ReferenceType } from '../environments/identifier';
@@ -8,7 +8,7 @@ import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-param
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { dataflowLogger } from '../logger';
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import { edgeDoesNotIncludeType, edgeIncludesType, EdgeType } from '../graph/edge';
+import { edgeIncludesType, EdgeType } from '../graph/edge';
 import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import {
 	type DataflowGraphVertexFunctionCall,
@@ -193,6 +193,7 @@ export function linkFunctionCallWithSingleTarget(
 	linkFunctionCallArguments(def.id, idMap, defName, id, info.args, graph);
 }
 
+const FCallLinkReadBits = EdgeType.Reads | EdgeType.Calls;
 /* there is _a lot_ potential for optimization here */
 function linkFunctionCall(
 	graph: DataflowGraph,
@@ -211,19 +212,19 @@ function linkFunctionCall(
 		return;
 	}
 
-	const readBits = EdgeType.Reads | EdgeType.Calls;
-	const functionDefinitionReadIds = [...edges].filter(([_, e]) =>
-		edgeDoesNotIncludeType(e.types, EdgeType.Argument)
-		&& edgeIncludesType(e.types, readBits)
-	).map(([target, _]) => target);
+	const functionDefinitionReadIds = new Set<NodeId>();
+	for(const [t, { types }] of edges.entries()) {
+		if(!isBuiltIn(t) && edgeIncludesType(types, FCallLinkReadBits)) {
+			functionDefinitionReadIds.add(t);
+		}
+	}
 
-	const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph)[0];
+	const [functionDefs] = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
 	for(const def of functionDefs.values()) {
-		guard(def.tag === VertexType.FunctionDefinition, () => `expected function definition, but got ${def.tag}`);
 		linkFunctionCallWithSingleTarget(graph, def, info, idMap);
 	}
 	if(thisGraph.isRoot(id) && functionDefs.size > 0) {
-		calledFunctionDefinitions.push({ functionCall: id, called: [...functionDefs.values()] });
+		calledFunctionDefinitions.push({ functionCall: id, called: functionDefs.values().toArray() });
 	}
 }
 
@@ -241,7 +242,9 @@ export function linkFunctionCalls(
 ): { functionCall: NodeId, called: readonly DataflowGraphVertexInfo[] }[] {
 	const calledFunctionDefinitions: { functionCall: NodeId, called: DataflowGraphVertexInfo[] }[] = [];
 	for(const [id, info] of thisGraph.verticesOfType(VertexType.FunctionCall)) {
-		linkFunctionCall(graph, id, info as DataflowGraphVertexFunctionCall, idMap, thisGraph, calledFunctionDefinitions);
+		if(!info.onlyBuiltin) {
+			linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
+		}
 	}
 	return calledFunctionDefinitions;
 }
@@ -275,28 +278,35 @@ export function getAllFunctionCallTargets(call: NodeId, graph: DataflowGraph, en
 		for(const target of functionCallTargets) {
 			found.push(target.id);
 		}
-		found = found.concat(...builtInTargets, functionCallDefs);
+		found = found.concat(Array.from(builtInTargets), functionCallDefs);
 	}
 
 	return found;
 }
 
+const LinkedFnFollowBits = EdgeType.Reads | EdgeType.DefinedBy | EdgeType.DefinedByOnCall;
+
 /**
  * Finds all linked function definitions starting from the given set of read ids.
  */
 export function getAllLinkedFunctionDefinitions(
 	functionDefinitionReadIds: ReadonlySet<NodeId>,
 	dataflowGraph: DataflowGraph
-): [Set<DataflowGraphVertexInfo>, Set<BuiltIn>] {
-	let potential: NodeId[] = functionDefinitionReadIds.values().toArray();
-	const visited = new Set<NodeId>();
-	const result = new Set<DataflowGraphVertexInfo>();
+): [Set<Required<DataflowGraphVertexFunctionDefinition>>, Set<BuiltIn>] {
+	const result = new Set<Required<DataflowGraphVertexFunctionDefinition>>();
 	const builtIns = new Set<BuiltIn>();
 
-	while(potential.length > 0) {
+	if(functionDefinitionReadIds.size === 0) {
+		return [result, builtIns];
+	}
+
+	const potential: NodeId[] = Array.from(functionDefinitionReadIds);
+	const visited = new Set<NodeId>();
+
+	while(potential.length !== 0) {
 		const currentId = potential.pop() as NodeId;
+		visited.add(currentId);
 
-		// do not traverse builtins further
 		if(isBuiltIn(currentId)) {
 			builtIns.add(currentId);
 			continue;
@@ -306,32 +316,36 @@ export function getAllLinkedFunctionDefinitions(
 		if(currentInfo === undefined) {
 			continue;
 		}
-		visited.add(currentId);
 
-		const outgoingEdges = currentInfo[1].entries().toArray();
+		const [vertex, edges] = currentInfo;
 
-		const returnEdges = outgoingEdges
-			.filter(([_, e]) => edgeIncludesType(e.types, EdgeType.Returns));
-		if(returnEdges.length > 0) {
-			// only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
-			potential = potential.concat(returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
+		// Found a function definition
+		if(vertex.subflow !== undefined) {
+			result.add(vertex as Required<DataflowGraphVertexFunctionDefinition>);
 			continue;
 		}
 
-		const followBits = EdgeType.Reads | EdgeType.DefinedBy | EdgeType.DefinedByOnCall;
-		const followEdges = outgoingEdges.filter(([_, e]) => edgeIncludesType(e.types, followBits));
+		let hasReturnEdge = false;
+		for(const [target, { types }] of edges) {
+			if(edgeIncludesType(types, EdgeType.Returns)) {
+				hasReturnEdge = true;
+				if(!visited.has(target)) {
+					potential.push(target);
+				}
+			}
+		}
 
-		if(currentInfo[0].subflow !== undefined) {
-			result.add(currentInfo[0]);
+		if(hasReturnEdge) {
+			continue;
 		}
 
-		// trace all joined reads
-		potential = potential.concat(
-			followEdges
-				.map(([target]) => target)
-				.filter(id => !visited.has(id))
-		);
+		for(const [target, { types }] of edges) {
+			if(edgeIncludesType(types, LinkedFnFollowBits) && !visited.has(target)) {
+				potential.push(target);
+			}
+		}
 	}
+
 	return [result, builtIns];
 }
 
@@ -393,10 +407,10 @@ export function linkCircularRedefinitionsWithinALoop(graph: DataflowGraph, openI
 	}
 
 	for(const [name, targets] of openIns.entries()) {
-		for(const out of lastOutgoing.values()) {
-			if(out.name === name) {
+		for(const { name: outName, nodeId } of lastOutgoing.values()) {
+			if(outName === name) {
 				for(const target of targets) {
-					graph.addEdge(target.nodeId, out.nodeId, EdgeType.Reads);
+					graph.addEdge(target.nodeId, nodeId, EdgeType.Reads);
 				}
 			}
 		}
@@ -412,8 +426,9 @@ export function reapplyLoopExitPoints(exits: readonly ExitPoint[], references: r
 
 	for(const ref of references) {
 		for(const cd of exitCds) {
+			const { id: cId, when: cWhen } = cd;
 			if(ref.controlDependencies) {
-				if(!ref.controlDependencies?.find(c => c.id === cd.id && c.when === cd.when)) {
+				if(!ref.controlDependencies?.find(c => c.id === cId && c.when === cWhen)) {
 					ref.controlDependencies.push({ ...cd, byIteration: true });
 				}
 			} else {
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-apply.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-apply.ts
@@ -30,7 +30,7 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
 	/** Should we unquote the function if it is given as a string? */
 	readonly unquoteFunction?:        boolean
 	/** Should the function be resolved in the global environment? */
-	readonly resolveInEnvironment:    'global' | 'local'
+	readonly resolveInEnvironment?:   'global' | 'local'
 	/** Should the value of the function be resolved? */
 	readonly resolveValue?:           boolean
 }
diff --git a/src/dataflow/internal/process/functions/call/built-in/built-in-expression-list.ts b/src/dataflow/internal/process/functions/call/built-in/built-in-expression-list.ts
diff --git a/src/dataflow/internal/process/functions/call/named-call-handling.ts b/src/dataflow/internal/process/functions/call/named-call-handling.ts

Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ export interface BuiltInIdentifierDefinition extends IdentifierReference {`
`81`	`81`	`type: ReferenceType.BuiltInFunction`
`82`	`82`	`definedAt: BuiltIn`
`83`	`83`	`processor: BuiltInIdentifierProcessor`
`84`		`- config?: object`
	`84`	`+ config?: ConfigOfBuiltInMappingName<BuiltInMappingName> & { libFn?: boolean }`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierReference {`
Original file line number	Diff line number	Diff line change
`@@ -413,7 +413,7 @@ export class DataflowGraphBuilder<`
`413`	`413`	`*`
`414`	`414`	`*/`
`415`	`415`	`export function getBuiltInSideEffect(name: string): LinkTo<RegExp> \| undefined {`
`416`		`- const got = DefaultBuiltinConfig.find(e => e.names.includes(name));`
	`416`	`+ const got = DefaultBuiltinConfig.find(e => (e.names as string[]).includes(name));`
`417`	`417`	`if(got?.type !== 'function') {`
`418`	`418`	`return undefined;`
`419`	`419`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {`
`30`	`30`	`/** Should we unquote the function if it is given as a string? */`
`31`	`31`	`readonly unquoteFunction?: boolean`
`32`	`32`	`/** Should the function be resolved in the global environment? */`
`33`		`- readonly resolveInEnvironment: 'global' \| 'local'`
	`33`	`+ readonly resolveInEnvironment?: 'global' \| 'local'`
`34`	`34`	`/** Should the value of the function be resolved? */`
`35`	`35`	`readonly resolveValue?: boolean`
`36`	`36`	`}`