mirror of https://github.com/sveltejs/svelte
pull/15820/head
S. Elliott Johnson
1 year ago
parent
4d6422cca4
commit
adb6e712e9
@ -1,301 +0,0 @@
|
|||||||
/** @import { Context, StateField } from '../../types.js' */
|
|
||||||
/** @import { AssignmentExpression, Identifier, Literal, MethodDefinition, PrivateIdentifier, PropertyDefinition, CallExpression, Expression, StaticBlock, SpreadElement } from 'estree' */
|
|
||||||
/** @import { Scope } from '#compiler' */
|
|
||||||
/** @import { StateCreationRuneName } from '../../../../../../utils.js' */
|
|
||||||
import * as b from '#compiler/builders';
|
|
||||||
import { is_state_creation_rune } from '../../../../../../utils.js';
|
|
||||||
import { regex_invalid_identifier_chars } from '../../../../patterns.js';
|
|
||||||
import { get_rune } from '../../../../scope.js';
|
|
||||||
import { should_proxy } from '../../utils.js';
|
|
||||||
|
|
||||||
export class ClassAnalysis {
|
|
||||||
/** @type {Map<string, StateField>} */
|
|
||||||
public_state = new Map();
|
|
||||||
|
|
||||||
/** @type {Map<string, StateField>} */
|
|
||||||
private_state = new Map();
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Any state fields discovered from {@link register_assignment} that need to be added to the class body.
|
|
||||||
* @type {Array<PropertyDefinition | MethodDefinition>}
|
|
||||||
*/
|
|
||||||
constructor_state_fields = [];
|
|
||||||
|
|
||||||
/** @type {Map<(MethodDefinition | PropertyDefinition)["key"], string>} */
|
|
||||||
#definition_names = new Map();
|
|
||||||
|
|
||||||
/** @type {Set<string>} */
|
|
||||||
#private_ids = new Set();
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {MethodDefinition | PropertyDefinition | StaticBlock} node
|
|
||||||
* @param {Scope} scope
|
|
||||||
*/
|
|
||||||
register_body_definition(node, scope) {
|
|
||||||
if (
|
|
||||||
!(
|
|
||||||
(node.type === 'PropertyDefinition' || node.type === 'MethodDefinition') &&
|
|
||||||
(node.key.type === 'Identifier' ||
|
|
||||||
node.key.type === 'PrivateIdentifier' ||
|
|
||||||
node.key.type === 'Literal')
|
|
||||||
)
|
|
||||||
) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We don't know if the node is stateful yet, but we still need to register some details.
|
|
||||||
* For example: If the node is a private identifier, we could accidentally conflict with it later
|
|
||||||
* if we create a private field for public state (as would happen in this example:)
|
|
||||||
*
|
|
||||||
* ```ts
|
|
||||||
* class Foo {
|
|
||||||
* #count = 0;
|
|
||||||
* count = $state(0); // would become #count if we didn't know about the private field above
|
|
||||||
* }
|
|
||||||
*/
|
|
||||||
|
|
||||||
const name = ClassAnalysis.#get_name(node.key, this.public_state);
|
|
||||||
if (!name) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// we store the deconflicted name in the map so that we can access it later
|
|
||||||
this.#definition_names.set(node.key, name);
|
|
||||||
|
|
||||||
const is_private = node.key.type === 'PrivateIdentifier';
|
|
||||||
if (is_private) {
|
|
||||||
this.#private_ids.add(name);
|
|
||||||
}
|
|
||||||
|
|
||||||
const rune = get_rune(node.value, scope);
|
|
||||||
if (!rune || !is_state_creation_rune(rune)) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (is_private) {
|
|
||||||
this.private_state.set(name, { kind: rune, id: /** @type {PrivateIdentifier} */ (node.key) });
|
|
||||||
} else {
|
|
||||||
// We can't set the ID until we've identified all of the private state fields,
|
|
||||||
// otherwise we might conflict with them. After registering all property definitions,
|
|
||||||
// call `finalize_property_definitions` to populate the IDs.
|
|
||||||
// @ts-expect-error this is set in `finalize_property_definitions`
|
|
||||||
this.public_state.set(name, { kind: rune, id: undefined });
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Resolves all of the registered public state fields to their final private IDs.
|
|
||||||
* Must be called after all property definitions have been registered.
|
|
||||||
*/
|
|
||||||
finalize_property_definitions() {
|
|
||||||
for (const [name, field] of this.public_state) {
|
|
||||||
field.id = this.#deconflict(name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Important note: It is a syntax error in JavaScript to try to assign to a private class field
|
|
||||||
* that was not declared in the class body. So there is absolutely no risk of unresolvable conflicts here.
|
|
||||||
*
|
|
||||||
* This function will modify the assignment expression passed to it if it is registered as a state field.
|
|
||||||
* @param {AssignmentExpression} node
|
|
||||||
* @param {Context} context
|
|
||||||
*/
|
|
||||||
register_assignment(node, context) {
|
|
||||||
if (
|
|
||||||
!(
|
|
||||||
node.operator === '=' &&
|
|
||||||
node.left.type === 'MemberExpression' &&
|
|
||||||
node.left.object.type === 'ThisExpression' &&
|
|
||||||
node.left.property.type === 'Identifier'
|
|
||||||
)
|
|
||||||
) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
const name = ClassAnalysis.#get_name(node.left.property, this.public_state);
|
|
||||||
if (!name) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
const rune = get_rune(node.right, context.state.scope);
|
|
||||||
if (!rune || !is_state_creation_rune(rune)) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
const id = this.#deconflict(name);
|
|
||||||
const field = { kind: rune, id };
|
|
||||||
this.public_state.set(name, field);
|
|
||||||
|
|
||||||
// We need to do two things:
|
|
||||||
// - Communicate to the class body visitor that it needs to append nodes to create a state field
|
|
||||||
// - Modify the assignment expression so that it's valid
|
|
||||||
this.constructor_state_fields.push(
|
|
||||||
...this.build_state_field(
|
|
||||||
false,
|
|
||||||
field,
|
|
||||||
node.left.property,
|
|
||||||
// this will initialize the field without assigning to it, delegating to the constructor
|
|
||||||
null,
|
|
||||||
context
|
|
||||||
)
|
|
||||||
);
|
|
||||||
|
|
||||||
// ...swap out the assignment to go directly against the private field
|
|
||||||
node.left.property = id;
|
|
||||||
// ...and swap out the assignment's value for the state field init
|
|
||||||
node.right = this.#build_init_value(
|
|
||||||
rune,
|
|
||||||
/** @type {CallExpression} */ (node.right).arguments[0],
|
|
||||||
context
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
*
|
|
||||||
* @param {PropertyDefinition | MethodDefinition | StaticBlock} node
|
|
||||||
* @param {Context} context
|
|
||||||
* @returns {Array<PropertyDefinition | MethodDefinition> | null}
|
|
||||||
*/
|
|
||||||
build_state_field_from_body_definition(node, context) {
|
|
||||||
if (
|
|
||||||
!(
|
|
||||||
node.type === 'PropertyDefinition' &&
|
|
||||||
(node.key.type === 'Identifier' ||
|
|
||||||
node.key.type === 'PrivateIdentifier' ||
|
|
||||||
node.key.type === 'Literal')
|
|
||||||
)
|
|
||||||
) {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
|
|
||||||
const name = this.#definition_names.get(node.key);
|
|
||||||
if (!name) throw new Error('This should not be possible'); // TODO
|
|
||||||
|
|
||||||
const is_private = node.key.type === 'PrivateIdentifier';
|
|
||||||
const field = (is_private ? this.private_state : this.public_state).get(name);
|
|
||||||
|
|
||||||
if (!field) {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
|
|
||||||
return this.build_state_field(
|
|
||||||
is_private,
|
|
||||||
field,
|
|
||||||
node.key,
|
|
||||||
// we can cast this because if we have a field for this definition it definitely is a call
|
|
||||||
// expression, otherwise it wouldn't have produced a rune earlier.
|
|
||||||
/** @type {CallExpression} */ (node.value),
|
|
||||||
context
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {boolean} is_private
|
|
||||||
* @param {StateField} field
|
|
||||||
* @param {(MethodDefinition | PropertyDefinition)["key"]} original_definition_id
|
|
||||||
* @param {CallExpression | null} call_expression
|
|
||||||
* @param {Context} context
|
|
||||||
*
|
|
||||||
* @returns {Array<PropertyDefinition | MethodDefinition>}
|
|
||||||
*/
|
|
||||||
build_state_field(is_private, field, original_definition_id, call_expression, context) {
|
|
||||||
let value;
|
|
||||||
if (!call_expression) {
|
|
||||||
// if there's no call expression, this is state that's created in the constructor.
|
|
||||||
// it's guaranteed to be the very first assignment to this field, so we initialize
|
|
||||||
// the field but don't assign to it.
|
|
||||||
value = null;
|
|
||||||
} else if (call_expression.arguments.length > 0) {
|
|
||||||
value = this.#build_init_value(field.kind, call_expression.arguments[0], context);
|
|
||||||
} else {
|
|
||||||
// if no arguments, we know it's state as `$derived()` is a compile error
|
|
||||||
value = b.call('$.state');
|
|
||||||
}
|
|
||||||
|
|
||||||
if (is_private) {
|
|
||||||
return [b.prop_def(field.id, value)];
|
|
||||||
}
|
|
||||||
|
|
||||||
const member = b.member(b.this, field.id);
|
|
||||||
const val = b.id('value');
|
|
||||||
return [
|
|
||||||
// #foo;
|
|
||||||
b.prop_def(field.id, value),
|
|
||||||
// get foo() { return this.#foo; }
|
|
||||||
b.method('get', original_definition_id, [], [b.return(b.call('$.get', member))]),
|
|
||||||
// set foo(value) { this.#foo = value; }
|
|
||||||
b.method(
|
|
||||||
'set',
|
|
||||||
original_definition_id,
|
|
||||||
[val],
|
|
||||||
[b.stmt(b.call('$.set', member, val, field.kind === '$state' && b.true))]
|
|
||||||
)
|
|
||||||
];
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
*
|
|
||||||
* @param {StateCreationRuneName} kind
|
|
||||||
* @param {Expression | SpreadElement} arg
|
|
||||||
* @param {Context} context
|
|
||||||
*/
|
|
||||||
#build_init_value(kind, arg, context) {
|
|
||||||
const init = /** @type {Expression} **/ (
|
|
||||||
context.visit(arg, {
|
|
||||||
...context.state,
|
|
||||||
class_analysis: this
|
|
||||||
})
|
|
||||||
);
|
|
||||||
|
|
||||||
switch (kind) {
|
|
||||||
case '$state':
|
|
||||||
return b.call(
|
|
||||||
'$.state',
|
|
||||||
should_proxy(init, context.state.scope) ? b.call('$.proxy', init) : init
|
|
||||||
);
|
|
||||||
case '$state.raw':
|
|
||||||
return b.call('$.state', init);
|
|
||||||
case '$derived':
|
|
||||||
return b.call('$.derived', b.thunk(init));
|
|
||||||
case '$derived.by':
|
|
||||||
return b.call('$.derived', init);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {string} name
|
|
||||||
* @returns {PrivateIdentifier}
|
|
||||||
*/
|
|
||||||
#deconflict(name) {
|
|
||||||
let deconflicted = name;
|
|
||||||
while (this.#private_ids.has(deconflicted)) {
|
|
||||||
deconflicted = '_' + deconflicted;
|
|
||||||
}
|
|
||||||
|
|
||||||
this.#private_ids.add(deconflicted);
|
|
||||||
return b.private_id(deconflicted);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param {Identifier | PrivateIdentifier | Literal} node
|
|
||||||
* @param {Map<string, unknown>} public_state
|
|
||||||
*/
|
|
||||||
static #get_name(node, public_state) {
|
|
||||||
if (node.type === 'Literal') {
|
|
||||||
let name = node.value?.toString().replace(regex_invalid_identifier_chars, '_');
|
|
||||||
|
|
||||||
// the above could generate conflicts because it has to generate a valid identifier
|
|
||||||
// so stuff like `0` and `1` or `state%` and `state^` will result in the same string
|
|
||||||
// so we have to de-conflict. We can only check `public_state` because private state
|
|
||||||
// can't have literal keys
|
|
||||||
while (name && public_state.has(name)) {
|
|
||||||
name = '_' + name;
|
|
||||||
}
|
|
||||||
return name;
|
|
||||||
} else {
|
|
||||||
return node.name;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,85 @@
|
|||||||
|
/** @import { Context } from '../../types.js' */
|
||||||
|
/** @import { MethodDefinition, PropertyDefinition, Expression, StaticBlock, SpreadElement } from 'estree' */
|
||||||
|
/** @import { StateCreationRuneName } from '../../../../../../utils.js' */
|
||||||
|
/** @import { AssignmentBuilder, ClassAnalysis, StateFieldBuilder } from '../../../shared/types.js' */
|
||||||
|
import * as b from '#compiler/builders';
|
||||||
|
import { create_class_analysis } from '../../../shared/class_analysis.js';
|
||||||
|
import { should_proxy } from '../../utils.js';
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {Array<MethodDefinition | PropertyDefinition | StaticBlock>} body
|
||||||
|
* @returns {ClassAnalysis<Context>}
|
||||||
|
*/
|
||||||
|
export function create_client_class_analysis(body) {
|
||||||
|
/** @type {StateFieldBuilder<Context>} */
|
||||||
|
function build_state_field({ is_private, field, node, context }) {
|
||||||
|
let original_id = node.type === 'AssignmentExpression' ? node.left : node.key;
|
||||||
|
let value;
|
||||||
|
if (node.type === 'AssignmentExpression') {
|
||||||
|
// if there's no call expression, this is state that's created in the constructor.
|
||||||
|
// it's guaranteed to be the very first assignment to this field, so we initialize
|
||||||
|
// the field but don't assign to it.
|
||||||
|
value = null;
|
||||||
|
} else if (node.value.arguments.length > 0) {
|
||||||
|
value = build_init_value(field.kind, node.value.arguments[0], context);
|
||||||
|
} else {
|
||||||
|
// if no arguments, we know it's state as `$derived()` is a compile error
|
||||||
|
value = b.call('$.state');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (is_private) {
|
||||||
|
return [b.prop_def(field.id, value)];
|
||||||
|
}
|
||||||
|
|
||||||
|
const member = b.member(b.this, field.id);
|
||||||
|
const val = b.id('value');
|
||||||
|
|
||||||
|
return [
|
||||||
|
// #foo;
|
||||||
|
b.prop_def(field.id, value),
|
||||||
|
// get foo() { return this.#foo; }
|
||||||
|
b.method('get', original_id, [], [b.return(b.call('$.get', member))]),
|
||||||
|
// set foo(value) { this.#foo = value; }
|
||||||
|
b.method(
|
||||||
|
'set',
|
||||||
|
original_id,
|
||||||
|
[val],
|
||||||
|
[b.stmt(b.call('$.set', member, val, field.kind === '$state' && b.true))]
|
||||||
|
)
|
||||||
|
];
|
||||||
|
}
|
||||||
|
|
||||||
|
/** @type {AssignmentBuilder<Context>} */
|
||||||
|
function build_assignment({ field, node, context }) {
|
||||||
|
// ...swap out the assignment to go directly against the private field
|
||||||
|
node.left.property = field.id;
|
||||||
|
// ...and swap out the assignment's value for the state field init
|
||||||
|
node.right = build_init_value(field.kind, node.right.arguments[0], context);
|
||||||
|
}
|
||||||
|
|
||||||
|
return create_class_analysis(body, build_state_field, build_assignment);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
*
|
||||||
|
* @param {StateCreationRuneName} kind
|
||||||
|
* @param {Expression | SpreadElement} arg
|
||||||
|
* @param {Context} context
|
||||||
|
*/
|
||||||
|
function build_init_value(kind, arg, context) {
|
||||||
|
const init = /** @type {Expression} **/ (context.visit(arg, context.state));
|
||||||
|
|
||||||
|
switch (kind) {
|
||||||
|
case '$state':
|
||||||
|
return b.call(
|
||||||
|
'$.state',
|
||||||
|
should_proxy(init, context.state.scope) ? b.call('$.proxy', init) : init
|
||||||
|
);
|
||||||
|
case '$state.raw':
|
||||||
|
return b.call('$.state', init);
|
||||||
|
case '$derived':
|
||||||
|
return b.call('$.derived', b.thunk(init));
|
||||||
|
case '$derived.by':
|
||||||
|
return b.call('$.derived', init);
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,71 @@
|
|||||||
|
/** @import { Expression, MethodDefinition, StaticBlock, PropertyDefinition } from 'estree' */
|
||||||
|
/** @import { Context } from '../../types.js' */
|
||||||
|
/** @import { AssignmentBuilder, StateFieldBuilder } from '../../../shared/types.js' */
|
||||||
|
/** @import { ClassAnalysis } from '../../../shared/types.js' */
|
||||||
|
|
||||||
|
import * as b from '#compiler/builders';
|
||||||
|
import { dev } from '../../../../../state.js';
|
||||||
|
import { create_class_analysis } from '../../../shared/class_analysis.js';
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {Array<MethodDefinition | PropertyDefinition | StaticBlock>} body
|
||||||
|
* @returns {ClassAnalysis<Context>}
|
||||||
|
*/
|
||||||
|
export function create_server_class_analysis(body) {
|
||||||
|
/** @type {StateFieldBuilder<Context>} */
|
||||||
|
function build_state_field({ is_private, field, node, context }) {
|
||||||
|
let original_id = node.type === 'AssignmentExpression' ? node.left : node.key;
|
||||||
|
let value;
|
||||||
|
if (node.type === 'AssignmentExpression') {
|
||||||
|
// This means it's a state assignment in the constructor (this.foo = $state('bar'))
|
||||||
|
// which means the state field needs to have no default value so that the initial
|
||||||
|
// value can be assigned in the constructor.
|
||||||
|
value = null;
|
||||||
|
} else if (field.kind !== '$derived' && field.kind !== '$derived.by') {
|
||||||
|
return [/** @type {PropertyDefinition} */ (context.visit(node, context.state))];
|
||||||
|
} else {
|
||||||
|
const init = /** @type {Expression} **/ (
|
||||||
|
context.visit(node.value.arguments[0], context.state)
|
||||||
|
);
|
||||||
|
value =
|
||||||
|
field.kind === '$derived.by' ? b.call('$.once', init) : b.call('$.once', b.thunk(init));
|
||||||
|
}
|
||||||
|
|
||||||
|
if (is_private) {
|
||||||
|
return [b.prop_def(field.id, value)];
|
||||||
|
}
|
||||||
|
// #foo;
|
||||||
|
const member = b.member(b.this, field.id);
|
||||||
|
|
||||||
|
const defs = [
|
||||||
|
// #foo;
|
||||||
|
b.prop_def(field.id, value),
|
||||||
|
// get foo() { return this.#foo; }
|
||||||
|
b.method('get', original_id, [], [b.return(b.call(member))])
|
||||||
|
];
|
||||||
|
|
||||||
|
// TODO make this work on server
|
||||||
|
if (dev) {
|
||||||
|
defs.push(
|
||||||
|
b.method(
|
||||||
|
'set',
|
||||||
|
original_id,
|
||||||
|
[b.id('_')],
|
||||||
|
[b.throw_error(`Cannot update a derived property ('${name}')`)]
|
||||||
|
)
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
return defs;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** @type {AssignmentBuilder<Context>} */
|
||||||
|
function build_assignment({ field, node, context }) {
|
||||||
|
node.left.property = field.id;
|
||||||
|
const init = /** @type {Expression} **/ (context.visit(node.right.arguments[0], context.state));
|
||||||
|
node.right =
|
||||||
|
field.kind === '$derived.by' ? b.call('$.once', init) : b.call('$.once', b.thunk(init));
|
||||||
|
}
|
||||||
|
|
||||||
|
return create_class_analysis(body, build_state_field, build_assignment);
|
||||||
|
}
|
||||||
@ -0,0 +1,334 @@
|
|||||||
|
/** @import { AssignmentExpression, Identifier, Literal, MethodDefinition, PrivateIdentifier, PropertyDefinition, StaticBlock } from 'estree' */
|
||||||
|
/** @import { StateField } from '../types.js' */
|
||||||
|
/** @import { Context as ClientContext } from '../client/types.js' */
|
||||||
|
/** @import { Context as ServerContext } from '../server/types.js' */
|
||||||
|
/** @import { StateCreationRuneName } from '../../../../utils.js' */
|
||||||
|
/** @import { AssignmentBuilder, ClassAnalysis, StateFieldBuilder, StatefulAssignment, StatefulPropertyDefinition } from './types.js' */
|
||||||
|
/** @import { Scope } from '../../scope.js' */
|
||||||
|
import * as b from '#compiler/builders';
|
||||||
|
import { once } from '../../../../internal/server/index.js';
|
||||||
|
import { is_state_creation_rune, STATE_CREATION_RUNES } from '../../../../utils.js';
|
||||||
|
import { regex_invalid_identifier_chars } from '../../patterns.js';
|
||||||
|
import { get_rune } from '../../scope.js';
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @template {ClientContext | ServerContext} TContext
|
||||||
|
* @param {Array<PropertyDefinition | MethodDefinition | StaticBlock>} body
|
||||||
|
* @param {StateFieldBuilder<TContext>} build_state_field
|
||||||
|
* @param {AssignmentBuilder<TContext>} build_assignment
|
||||||
|
* @returns {ClassAnalysis<TContext>}
|
||||||
|
*/
|
||||||
|
export function create_class_analysis(body, build_state_field, build_assignment) {
|
||||||
|
/** @type {Map<string, StateField>} */
|
||||||
|
const public_fields = new Map();
|
||||||
|
|
||||||
|
/** @type {Map<string, StateField>} */
|
||||||
|
const private_fields = new Map();
|
||||||
|
|
||||||
|
/** @type {Array<PropertyDefinition | MethodDefinition>} */
|
||||||
|
const new_body = [];
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Private identifiers in use by this analysis.
|
||||||
|
* Factoid: Unlike public class fields, private fields _must_ be declared in the class body
|
||||||
|
* before use. So the following is actually a JavaScript syntax error, which means we can
|
||||||
|
* be 100% certain we know all private fields after parsing the class body:
|
||||||
|
*
|
||||||
|
* ```ts
|
||||||
|
* class Example {
|
||||||
|
* constructor() {
|
||||||
|
* this.public = 'foo'; // not a problem!
|
||||||
|
* this.#private = 'bar'; // JavaScript parser error
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* ```
|
||||||
|
* @type {Set<string>}
|
||||||
|
*/
|
||||||
|
const private_ids = new Set();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A registry of functions to call to complete body modifications.
|
||||||
|
* Replacements may insert more than one node to the body. The original
|
||||||
|
* body should not be modified -- instead, replacers should push new
|
||||||
|
* nodes to new_body.
|
||||||
|
*
|
||||||
|
* @type {Array<() => void>}
|
||||||
|
*/
|
||||||
|
const replacers = [];
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {string} name
|
||||||
|
* @param {boolean} is_private
|
||||||
|
* @param {ReadonlyArray<StateCreationRuneName>} [kinds]
|
||||||
|
*/
|
||||||
|
function get_field(name, is_private, kinds = STATE_CREATION_RUNES) {
|
||||||
|
const value = (is_private ? private_fields : public_fields).get(name);
|
||||||
|
if (value && kinds.includes(value.kind)) {
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {TContext} context
|
||||||
|
* @returns {TContext}
|
||||||
|
*/
|
||||||
|
function create_child_context(context) {
|
||||||
|
return {
|
||||||
|
...context,
|
||||||
|
state: {
|
||||||
|
...context.state,
|
||||||
|
class_analysis
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {TContext} context
|
||||||
|
*/
|
||||||
|
function generate_body(context) {
|
||||||
|
const child_context = create_child_context(context);
|
||||||
|
for (const node of body) {
|
||||||
|
const was_registered = register_body_definition(node, child_context);
|
||||||
|
if (!was_registered) {
|
||||||
|
new_body.push(
|
||||||
|
/** @type {PropertyDefinition | MethodDefinition} */ (
|
||||||
|
// @ts-expect-error generics silliness
|
||||||
|
child_context.visit(node, child_context.state)
|
||||||
|
)
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (const replacer of replacers) {
|
||||||
|
replacer();
|
||||||
|
}
|
||||||
|
|
||||||
|
return new_body;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Important note: It is a syntax error in JavaScript to try to assign to a private class field
|
||||||
|
* that was not declared in the class body. So there is absolutely no risk of unresolvable conflicts here.
|
||||||
|
*
|
||||||
|
* This function will modify the assignment expression passed to it if it is registered as a state field.
|
||||||
|
* @param {AssignmentExpression} node
|
||||||
|
* @param {TContext} context
|
||||||
|
*/
|
||||||
|
function register_assignment(node, context) {
|
||||||
|
const child_context = create_child_context(context);
|
||||||
|
if (
|
||||||
|
!(
|
||||||
|
node.operator === '=' &&
|
||||||
|
node.left.type === 'MemberExpression' &&
|
||||||
|
node.left.object.type === 'ThisExpression' &&
|
||||||
|
node.left.property.type === 'Identifier'
|
||||||
|
)
|
||||||
|
) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
const name = get_name(node.left.property);
|
||||||
|
if (!name) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
const parsed = parse_stateful_assignment(node, child_context.state.scope);
|
||||||
|
if (!parsed) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
const { stateful_assignment, rune } = parsed;
|
||||||
|
|
||||||
|
const id = deconflict(name);
|
||||||
|
const field = { kind: rune, id };
|
||||||
|
public_fields.set(name, field);
|
||||||
|
|
||||||
|
const replacer = () => {
|
||||||
|
const nodes = build_state_field({
|
||||||
|
is_private: false,
|
||||||
|
field,
|
||||||
|
node: stateful_assignment,
|
||||||
|
context: child_context
|
||||||
|
});
|
||||||
|
if (!nodes) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
new_body.push(...nodes);
|
||||||
|
};
|
||||||
|
replacers.push(replacer);
|
||||||
|
|
||||||
|
build_assignment({
|
||||||
|
node: stateful_assignment,
|
||||||
|
field,
|
||||||
|
context: child_context
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {PropertyDefinition | MethodDefinition | StaticBlock} node
|
||||||
|
* @param {TContext} child_context
|
||||||
|
* @returns {boolean} if this node is stateful and was registered
|
||||||
|
*/
|
||||||
|
function register_body_definition(node, child_context) {
|
||||||
|
if (node.type === 'MethodDefinition' && node.kind === 'constructor') {
|
||||||
|
// life is easier to reason about if we've visited the constructor
|
||||||
|
// and registered its public state field before we start building
|
||||||
|
// anything else
|
||||||
|
replacers.unshift(() => {
|
||||||
|
new_body.push(
|
||||||
|
/** @type {MethodDefinition} */ (
|
||||||
|
// @ts-expect-error generics silliness
|
||||||
|
child_context.visit(node, child_context.state)
|
||||||
|
)
|
||||||
|
);
|
||||||
|
});
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (
|
||||||
|
!(
|
||||||
|
(node.type === 'PropertyDefinition' || node.type === 'MethodDefinition') &&
|
||||||
|
(node.key.type === 'Identifier' ||
|
||||||
|
node.key.type === 'PrivateIdentifier' ||
|
||||||
|
node.key.type === 'Literal')
|
||||||
|
)
|
||||||
|
) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* We don't know if the node is stateful yet, but we still need to register some details.
|
||||||
|
* For example: If the node is a private identifier, we could accidentally conflict with it later
|
||||||
|
* if we create a private field for public state (as would happen in this example:)
|
||||||
|
*
|
||||||
|
* ```ts
|
||||||
|
* class Foo {
|
||||||
|
* #count = 0;
|
||||||
|
* count = $state(0); // would become #count if we didn't know about the private field above
|
||||||
|
* }
|
||||||
|
*/
|
||||||
|
|
||||||
|
const name = get_name(node.key);
|
||||||
|
if (!name) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
const is_private = node.key.type === 'PrivateIdentifier';
|
||||||
|
if (is_private) {
|
||||||
|
private_ids.add(name);
|
||||||
|
}
|
||||||
|
|
||||||
|
const parsed = prop_def_is_stateful(node, child_context.state.scope);
|
||||||
|
if (!parsed) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
const { stateful_prop_def, rune } = parsed;
|
||||||
|
|
||||||
|
let field;
|
||||||
|
if (is_private) {
|
||||||
|
field = {
|
||||||
|
kind: rune,
|
||||||
|
id: /** @type {PrivateIdentifier} */ (stateful_prop_def.key)
|
||||||
|
};
|
||||||
|
private_fields.set(name, field);
|
||||||
|
} else {
|
||||||
|
// We can't set the ID until we've identified all of the private state fields,
|
||||||
|
// otherwise we might conflict with them. After registering all property definitions,
|
||||||
|
// call `finalize_property_definitions` to populate the IDs. So long as we don't
|
||||||
|
// access the ID before the end of this loop, we're fine!
|
||||||
|
const id = once(() => deconflict(name));
|
||||||
|
field = {
|
||||||
|
kind: rune,
|
||||||
|
get id() {
|
||||||
|
return id();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
public_fields.set(name, field);
|
||||||
|
}
|
||||||
|
|
||||||
|
const replacer = () => {
|
||||||
|
const nodes = build_state_field({
|
||||||
|
is_private,
|
||||||
|
field,
|
||||||
|
node: stateful_prop_def,
|
||||||
|
context: child_context
|
||||||
|
});
|
||||||
|
if (!nodes) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
new_body.push(...nodes);
|
||||||
|
};
|
||||||
|
replacers.push(replacer);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {string} name
|
||||||
|
* @returns {PrivateIdentifier}
|
||||||
|
*/
|
||||||
|
function deconflict(name) {
|
||||||
|
let deconflicted = name;
|
||||||
|
while (private_ids.has(deconflicted)) {
|
||||||
|
deconflicted = '_' + deconflicted;
|
||||||
|
}
|
||||||
|
|
||||||
|
private_ids.add(deconflicted);
|
||||||
|
return b.private_id(deconflicted);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {Identifier | PrivateIdentifier | Literal} node
|
||||||
|
*/
|
||||||
|
function get_name(node) {
|
||||||
|
if (node.type === 'Literal') {
|
||||||
|
let name = node.value?.toString().replace(regex_invalid_identifier_chars, '_');
|
||||||
|
|
||||||
|
// the above could generate conflicts because it has to generate a valid identifier
|
||||||
|
// so stuff like `0` and `1` or `state%` and `state^` will result in the same string
|
||||||
|
// so we have to de-conflict. We can only check `public_fields` because private state
|
||||||
|
// can't have literal keys
|
||||||
|
while (name && public_fields.has(name)) {
|
||||||
|
name = '_' + name;
|
||||||
|
}
|
||||||
|
return name;
|
||||||
|
} else {
|
||||||
|
return node.name;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
const class_analysis = {
|
||||||
|
get_field,
|
||||||
|
generate_body,
|
||||||
|
register_assignment
|
||||||
|
};
|
||||||
|
|
||||||
|
return class_analysis;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* `get_rune` is really annoying because it really guarantees this already
|
||||||
|
* we just need this to tell the type system about it
|
||||||
|
* @param {AssignmentExpression} node
|
||||||
|
* @param {Scope} scope
|
||||||
|
* @returns {{ stateful_assignment: StatefulAssignment, rune: StateCreationRuneName } | null}
|
||||||
|
*/
|
||||||
|
function parse_stateful_assignment(node, scope) {
|
||||||
|
const rune = get_rune(node.right, scope);
|
||||||
|
if (!rune || !is_state_creation_rune(rune)) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
return { stateful_assignment: /** @type {StatefulAssignment} */ (node), rune };
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param {PropertyDefinition | MethodDefinition} node
|
||||||
|
* @param {Scope} scope
|
||||||
|
* @returns {{ stateful_prop_def: StatefulPropertyDefinition, rune: StateCreationRuneName } | null}
|
||||||
|
*/
|
||||||
|
function prop_def_is_stateful(node, scope) {
|
||||||
|
const rune = get_rune(node.value, scope);
|
||||||
|
if (!rune || !is_state_creation_rune(rune)) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
return { stateful_prop_def: /** @type {StatefulPropertyDefinition} */ (node), rune };
|
||||||
|
}
|
||||||
@ -0,0 +1,63 @@
|
|||||||
|
import type { AssignmentExpression, CallExpression, Identifier, MemberExpression, PropertyDefinition, MethodDefinition, PrivateIdentifier, ThisExpression } from 'estree';
|
||||||
|
import type { StateField } from '../types';
|
||||||
|
import type { Context as ServerContext } from '../server/types';
|
||||||
|
import type { Context as ClientContext } from '../client/types';
|
||||||
|
import type { StateCreationRuneName } from '../../../../utils';
|
||||||
|
|
||||||
|
export type StatefulAssignment = AssignmentExpression & {
|
||||||
|
left: MemberExpression & {
|
||||||
|
object: ThisExpression;
|
||||||
|
property: Identifier | PrivateIdentifier
|
||||||
|
};
|
||||||
|
right: CallExpression;
|
||||||
|
};
|
||||||
|
|
||||||
|
export type StatefulPropertyDefinition = PropertyDefinition & {
|
||||||
|
key: Identifier | PrivateIdentifier;
|
||||||
|
value: CallExpression;
|
||||||
|
};
|
||||||
|
|
||||||
|
export type StateFieldBuilderParams<TContext extends ServerContext | ClientContext> = {
|
||||||
|
is_private: boolean;
|
||||||
|
field: StateField;
|
||||||
|
node: StatefulAssignment | StatefulPropertyDefinition;
|
||||||
|
context: TContext;
|
||||||
|
};
|
||||||
|
|
||||||
|
export type StateFieldBuilder<TContext extends ServerContext | ClientContext> = (
|
||||||
|
params: StateFieldBuilderParams<TContext>
|
||||||
|
) => Array<PropertyDefinition | MethodDefinition>;
|
||||||
|
|
||||||
|
export type AssignmentBuilderParams<TContext extends ServerContext | ClientContext> = {
|
||||||
|
node: StatefulAssignment;
|
||||||
|
field: StateField;
|
||||||
|
context: TContext;
|
||||||
|
};
|
||||||
|
|
||||||
|
export type AssignmentBuilder<TContext extends ServerContext | ClientContext> = (params: AssignmentBuilderParams<TContext>) => void;
|
||||||
|
|
||||||
|
export type ClassAnalysis<TContext extends ServerContext | ClientContext> = {
|
||||||
|
/**
|
||||||
|
* @param name - The name of the field.
|
||||||
|
* @param is_private - Whether the field is private (whether its name starts with '#').
|
||||||
|
* @param kinds - What kinds of state creation runes you're looking for, eg. only '$derived.by'.
|
||||||
|
* @returns The field if it exists and matches the given criteria, or null.
|
||||||
|
*/
|
||||||
|
get_field: (name: string, is_private: boolean, kinds?: Array<StateCreationRuneName>) => StateField | undefined;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Given the body of a class, generate a new body with stateful fields.
|
||||||
|
* This assumes that {@link register_assignment} is registered to be called
|
||||||
|
* for all `AssignmentExpression` nodes in the class body.
|
||||||
|
* @param context - The context associated with the `ClassBody`.
|
||||||
|
* @returns The new body.
|
||||||
|
*/
|
||||||
|
generate_body: (context: TContext) => Array<PropertyDefinition | MethodDefinition>;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Register an assignment expression. This checks to see if the assignment is creating
|
||||||
|
* a state field on the class. If it is, it registers that state field and modifies the
|
||||||
|
* assignment expression.
|
||||||
|
*/
|
||||||
|
register_assignment: (node: AssignmentExpression, context: TContext) => void;
|
||||||
|
}
|
||||||
Loading…
Reference in new issue