[compiler] Resolve members through template parameters.#9868
Conversation
…ateparameter-metaproperties
commit: |
|
All changed packages have been documented.
Show changes
|
|
You can try these changes here
|
|
Solid illustration of functionality here (see |
…ateparameter-metaproperties
There was a problem hiding this comment.
Pull request overview
This PR introduces a new TemplateParameterAccess type to the TypeSpec compiler, enabling member access (.) and meta-member access (::) through template parameters based on their constraints. For instance, if R extends Resource and Resource guarantees a property id, then R.id can be used as a type in template declarations.
Changes:
- Adds a new
TemplateParameterAccessinternal type and comprehensive resolution logic inchecker.tsandname-resolver.tsfor resolving member/meta-member access through template parameter constraints - Updates all subsystems that handle the
Typeunion (semantic walker, type relation checker, string template utils, type name utils, completions, hover, document highlight) to recognize the new type - Updates dependent packages (
html-program-viewer,http-server-csharp,tspd) and adds tests for completions, hover, document highlighting, and reference resolution
Reviewed changes
Copilot reviewed 18 out of 18 changed files in this pull request and generated 4 comments.
Show a summary per file
| File | Description |
|---|---|
packages/compiler/src/core/types.ts |
Adds TemplateParameterAccess interface and includes it in the Type union |
packages/compiler/src/core/checker.ts |
Core logic for resolving template parameter access (member & meta-member), caching, and completions |
packages/compiler/src/core/name-resolver.ts |
Adds getMetaMemberNames API to expose available meta-member names for completion and validation |
packages/compiler/src/core/semantic-walker.ts |
Adds navigation support for TemplateParameterAccess in the semantic walker |
packages/compiler/src/core/type-relation-checker.ts |
Treats TemplateParameterAccess like TemplateParameter (uses constraint for assignability) |
packages/compiler/src/core/helpers/type-name-utils.ts |
Returns path as the type name for TemplateParameterAccess |
packages/compiler/src/core/helpers/string-template-utils.ts |
Handles TemplateParameterAccess in string template serialization check |
packages/compiler/src/server/type-signature.ts |
Renders hover signature for TemplateParameterAccess as (template access) |
packages/compiler/test/checker/references.test.ts |
Tests for resolving references through template parameter constraints |
packages/compiler/test/checker/operations.test.ts |
Tests that operation parameters resolve correctly with template member types |
packages/compiler/test/server/completion.test.ts |
Tests for IDE completions through constrained template parameters |
packages/compiler/test/server/get-hover.test.ts |
Tests for hover information on template parameter access expressions |
packages/compiler/test/server/document-highlight.test.ts |
Tests for document highlighting of template access references |
packages/html-program-viewer/src/react/type-config.ts |
Registers TemplateParameterAccess in the program viewer UI |
packages/http-server-csharp/src/lib/service.ts |
Handles TemplateParameterAccess as an unsupported type (returns undefined) |
packages/tspd/src/ref-doc/utils/type-signature.ts |
Renders TemplateParameterAccess signature in documentation generation |
.chronus/changes/*.md |
Two changeset entries for the compiler (feature) and dependent packages (internal) |
…ateparameter-metaproperties
…ateparameter-metaproperties
…ateparameter-metaproperties
…ateparameter-metaproperties
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
…ateparameter-metaproperties
…ateparameter-metaproperties
This PR enables resolving member symbols (properties, metaproperties) through template parameters based on constraints.
It accomplishes this by adding a new Type node,
TemplateParameterAccess, which is a semantic equivalent of a member expression where the base of the member access is a template parameter or another template parameter access expression. These are only visible inside the context of template declarations. Otherwise, like template parameters, they become "resolved" to concrete types when the template is instantiated.This allows you to invoke metaproperties such as
::returnTypewhen a template item is constrained to anOperation. This is recursive, soI.o::returnTypeis allowed ifIis an interface that is proven to have an operation namedo. proven is the keyword. Members only resolve if the constraint guarantees their presence.This feature enables much more powerful templates. For example: