[cleanup]: remove partials

guides/01-introduction.md

@@ -17,7 +17,7 @@ Glimmer is a flexible, low-level rendering pipeline for building a "live" DOM
 from a superset of the [Handlebars][handlebars] templating language that can
 subsequently be updated cheaply when data changes.
 
-In addition to the basic Handlebars features such as helpers and partials,
+In addition to the basic Handlebars features such as helpers,
 Glimmer also comes with built-in support for a very flexible and powerful
 primitive called "Components" and a set of low-level hooks which the host
 environment can use to build other high-level, user-facing features.

guides/11-glossary.md

@@ -269,20 +269,6 @@ See also: [Reference](#reference), [References (guide)][path-reference-guide]
 
 [path-reference-guide]: ./04-references.md#references-in-glimmer
 
-## Partial
-
-A partial is a kind of non-component template that can be included inside other
-templates, inheriting the lexical scope of its surrounding environment.
-
-Similar to `eval()` in JavaScript, it behaves as though you copied and pasted
-the partial's template into the parent template, inheriting all of the variables
-in scope. Also like `eval()`, its highly dynamic nature disables many categories
-of optimization wherever it is used.
-
-Using partials is discouraged. They are implemented for backwards compatibility
-with Ember and should not be used in new host environments. Everything that can
-be accomplished with a partial can be better accomplished with a component.
-
 ## Constant Pool
 
 The constant pool is a data structure that contains arrays of JavaScript values

packages/@glimmer/benchmark-env/src/benchmark/create-registry.ts

@@ -82,7 +82,6 @@ export default function createRegistry(): Registry {
         lookupHelper: (name) => helpers.get(name) ?? null,
         lookupModifier: (name) => modifiers.get(name) ?? null,
         lookupComponent: (name) => components.get(name) ?? null,
-        lookupPartial: () => null,
 
         lookupBuiltInHelper: () => null,
         lookupBuiltInModifier: () => null,
@@ -97,7 +96,6 @@ export default function createRegistry(): Registry {
         context,
         {
           lookupComponent: () => null,
-          lookupPartial: () => null,
         },
         component,
         args,

packages/@glimmer/compiler/lib/PASSES.md

@@ -14,7 +14,7 @@ The input to the preprocessor is _the AST_. The AST is the result of parsing a t
 
 In addition to allocating symbols for variable references that refer to in-scope bindings (introduced by block parameters), this pass also allocates symbols for `@arg` references, as well as blocks that are references via the `{{yield}}`, `(has-block)` and `(has-block-params)` keywords.
 
-Finally, this pass is responsible for identifying the presence of the `{{partial}}` and `{{debugger}}` keywords, which require symbol maps at runtime.
+Finally, this pass is responsible for identifying the presence of the and `{{debugger}}` keywords, which require symbol maps at runtime.
 
 **Encoding**: The encoding pass turns the MIR into the wire format, which is suitable for wire transport. The current encoding pass is hardcoded to emit the wire format (documented in `@glimmer/wire-format`). This is the stage where any optimizations on the representation are performed (like erasing trailing nulls, or other simple packing optimizations).
 

packages/@glimmer/compiler/lib/builder/builder-interface.ts

@@ -56,8 +56,7 @@ export interface Variable {
    *
    * - strict mode variables always refer to in-scope variables
    * - loose mode variables use this algorithm:
-   *   1. if the template is invoked as a partial, look for an in-scope partial variable
-   *   2. otherwise, fall back to `this.<name>`
+   *   1. otherwise, fall back to `this.<name>`
    */
   mode: 'loose' | 'strict';
 }

packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts

@@ -1,6 +1,5 @@
 import { CurriedType } from '@glimmer/interfaces';
 import { ASTv2, generateSyntaxError, SourceSlice, SourceSpan } from '@glimmer/syntax';
-import { expect } from '@glimmer/util';
 
 import { Err, Ok, Result } from '../../../shared/result';
 import * as mir from '../../2-encoding/mir';
@@ -75,75 +74,6 @@ export const APPEND_KEYWORDS = keywords('Append')
       );
     },
   })
-  .kw('partial', {
-    assert(
-      node: ASTv2.AppendContent,
-      state: NormalizationState
-    ): Result<ASTv2.ExpressionNode | undefined> {
-      if (state.isStrict) {
-        return Err(
-          generateSyntaxError('{{partial}} is not allowed in strict mode templates', node.loc)
-        );
-      }
-
-      let {
-        args: { positional, named },
-      } = node;
-      let { trusting } = node;
-
-      if (positional.isEmpty()) {
-        return Err(
-          generateSyntaxError(
-            `Partial found with no arguments. You must specify a template name`,
-            node.loc
-          )
-        );
-      } else if (positional.size !== 1) {
-        return Err(
-          generateSyntaxError(
-            `Partial found with ${positional.exprs.length} arguments. You must specify a template name`,
-            node.loc
-          )
-        );
-      }
-
-      if (named.isEmpty()) {
-        if (trusting) {
-          return Err(
-            generateSyntaxError(
-              `{{{partial ...}}} is not supported, please use {{partial ...}} instead`,
-              node.loc
-            )
-          );
-        }
-
-        return Ok(expect(positional.nth(0), `already confirmed that positional has a 0th entry`));
-      } else {
-        return Err(generateSyntaxError(`Partial does not take any named argument`, node.loc));
-      }
-    },
-
-    translate(
-      { node, state }: { node: ASTv2.AppendContent; state: NormalizationState },
-      expr: ASTv2.ExpressionNode | undefined
-    ): Result<mir.Statement> {
-      state.scope.setHasEval();
-
-      let visited =
-        expr === undefined
-          ? Ok(
-              new ASTv2.LiteralExpression({
-                loc: SourceSpan.synthetic('undefined'),
-                value: undefined,
-              })
-            )
-          : VISIT_EXPRS.visit(expr, state);
-
-      return visited.mapOk(
-        (target) => new mir.Partial({ loc: node.loc, scope: state.scope, target })
-      );
-    },
-  })
   .kw('debugger', {
     assert(node: ASTv2.AppendContent): Result<void> {
       let { args } = node;

packages/@glimmer/compiler/lib/passes/2-encoding/content.ts

@@ -44,8 +44,6 @@ export class ContentEncoder {
     switch (stmt.type) {
       case 'Debugger':
         return [SexpOpcodes.Debugger, stmt.scope.getEvalInfo()];
-      case 'Partial':
-        return this.Partial(stmt);
       case 'AppendComment':
         return this.AppendComment(stmt);
       case 'AppendTextNode':
@@ -79,10 +77,6 @@ export class ContentEncoder {
     }
   }
 
-  Partial({ target, scope }: mir.Partial): WireFormat.Statements.Partial {
-    return [SexpOpcodes.Partial, EXPR.expr(target), scope.getEvalInfo()];
-  }
-
   Yield({ to, positional }: mir.Yield): WireFormat.Statements.Yield {
     return [SexpOpcodes.Yield, to, EXPR.Positional(positional)];
   }

packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts

@@ -136,10 +136,6 @@ export class Yield extends node('Yield').fields<{
   to: number;
   positional: Positional;
 }>() {}
-export class Partial extends node('Partial').fields<{
-  target: ExpressionNode;
-  scope: SymbolTable;
-}>() {}
 export class Debugger extends node('Debugger').fields<{ scope: SymbolTable }>() {}
 
 export class CallExpression extends node('CallExpression').fields<{
@@ -243,7 +239,6 @@ export type Statement =
   | Component
   | SimpleElement
   | InvokeBlock
-  | Partial
   | AppendComment
   | If
   | Each

packages/@glimmer/compiler/lib/wire-format-debug.ts

@@ -94,9 +94,6 @@ export default class WireFormatDebugger {
         case Op.Yield:
           return ['yield', opcode[1], this.formatParams(opcode[2])];
 
-        case Op.Partial:
-          return ['partial', this.formatOpcode(opcode[1]), opcode[2]];
-
         case Op.DynamicArg:
           return ['dynamic-arg', opcode[1], this.formatOpcode(opcode[2])];
 

packages/@glimmer/debug/lib/opcode-metadata.ts

@@ -1302,29 +1302,6 @@ METADATA[Op.DidRenderLayout] = {
   check: true,
 };
 
-METADATA[Op.InvokePartial] = {
-  name: 'InvokePartial',
-  mnemonic: 'invokepartial',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'owner',
-      type: 'owner',
-    },
-    {
-      name: 'symbols',
-      type: 'str-array',
-    },
-    {
-      name: 'evalInfo',
-      type: 'array',
-    },
-  ],
-  operands: 3,
-  check: true,
-};
-
 METADATA[Op.ResolveMaybeLocal] = {
   name: 'ResolveMaybeLocal',
   mnemonic: 'eval_varload',

packages/@glimmer/integration-tests/lib/modes/jit/compilation-context.ts

@@ -2,7 +2,6 @@ import {
   CompileTimeResolver,
   Option,
   ResolvedComponentDefinition,
-  PartialDefinition,
   HelperDefinitionState,
   ModifierDefinitionState,
 } from '@glimmer/interfaces';
@@ -23,10 +22,6 @@ export default class JitCompileTimeLookup implements CompileTimeResolver {
     return this.resolver.lookupComponent(name, owner);
   }
 
-  lookupPartial(name: string): Option<PartialDefinition> {
-    return this.resolver.lookupPartial(name);
-  }
-
   lookupBuiltInHelper(_name: string): Option<HelperDefinitionState> {
     return null;
   }

packages/@glimmer/integration-tests/lib/modes/jit/delegate.ts

@@ -52,7 +52,6 @@ import {
   registerHelper,
   registerInternalHelper,
   registerModifier,
-  registerPartial,
 } from './register';
 import { TestJitRegistry } from './registry';
 import { renderTemplate } from './render';
@@ -185,10 +184,6 @@ export class JitRenderDelegate implements RenderDelegate {
     return clientBuilder(env, cursor);
   }
 
-  registerPartial(name: string, content: string) {
-    registerPartial(this.registry, name, content);
-  }
-
   getSelf(_env: Environment, context: unknown): Reference {
     if (!this.self) {
       this.self = createConstRef(context, 'this');

packages/@glimmer/integration-tests/lib/modes/jit/register.ts

@@ -3,7 +3,6 @@ import {
   Option,
   Helper as GlimmerHelper,
   InternalModifierManager,
-  PartialDefinition,
   TemplateFactory,
   ResolutionTimeConstants,
   CurriedType,
@@ -16,10 +15,9 @@ import {
   TestModifierDefinitionState,
   TestModifierManager,
 } from '../../modifiers';
-import { PartialDefinitionImpl } from '@glimmer/opcode-compiler';
 import { ComponentKind, ComponentTypes } from '../../components';
 import { CurriedValue, curry, templateOnlyComponent } from '@glimmer/runtime';
-import { createTemplate, preprocess } from '../../compile';
+import { createTemplate } from '../../compile';
 import {
   getInternalComponentManager,
   setComponentTemplate,
@@ -108,16 +106,6 @@ export function registerModifier(
   registry.register('modifier', name, state);
 }
 
-export function registerPartial(
-  registry: TestJitRegistry,
-  name: string,
-  source: string
-): PartialDefinition {
-  let definition = new PartialDefinitionImpl(name, preprocess(source));
-  registry.register('partial', name, definition);
-  return definition;
-}
-
 export function registerComponent<K extends ComponentKind>(
   registry: TestJitRegistry,
   type: K,

packages/@glimmer/integration-tests/lib/modes/jit/registry.ts

@@ -3,7 +3,6 @@ import {
   ResolvedComponentDefinition,
   Invocation,
   Option,
-  PartialDefinition,
   Template,
   HelperDefinitionState,
   ModifierDefinitionState,
@@ -22,7 +21,6 @@ CIRCULAR_OBJECT.inner.outer = CIRCULAR_OBJECT;
 export interface Lookup {
   helper: HelperDefinitionState;
   modifier: ModifierDefinitionState;
-  partial: PartialDefinition;
   component: ResolvedComponentDefinition;
   template: Invocation;
   compilable: Template;
@@ -51,7 +49,6 @@ export class TypedRegistry<T> {
 export default class Registry {
   helper = new TypedRegistry<HelperDefinitionState>();
   modifier = new TypedRegistry<ModifierDefinitionState>();
-  partial = new TypedRegistry<PartialDefinition>();
   component = new TypedRegistry<
     ResolvedComponentDefinition<object, unknown, InternalComponentManager>
   >();

packages/@glimmer/integration-tests/lib/modes/jit/resolver.ts

@@ -2,7 +2,6 @@ import {
   RuntimeResolver,
   Option,
   ResolvedComponentDefinition,
-  PartialDefinition,
   ModifierDefinitionState,
   HelperDefinitionState,
 } from '@glimmer/interfaces';
@@ -22,8 +21,4 @@ export class TestJitRuntimeResolver implements RuntimeResolver {
   lookupComponent(name: string, _owner?: object): Option<ResolvedComponentDefinition> {
     return this.registry.lookupComponent(name);
   }
-
-  lookupPartial(name: string): Option<PartialDefinition> {
-    return this.registry.lookup('partial', name);
-  }
 }

packages/@glimmer/integration-tests/lib/modes/rehydration/delegate.ts

@@ -32,7 +32,6 @@ import {
   registerHelper,
   registerInternalHelper,
   registerModifier,
-  registerPartial,
 } from '../jit/register';
 import { TestJitRegistry } from '../jit/registry';
 import { renderTemplate } from '../jit/render';
@@ -196,11 +195,6 @@ export class RehydrationDelegate implements RenderDelegate {
     registerInternalHelper(this.serverRegistry, name, helper);
   }
 
-  registerPartial(name: string, content: string) {
-    registerPartial(this.clientRegistry, name, content);
-    registerPartial(this.serverRegistry, name, content);
-  }
-
   registerModifier(name: string, ModifierClass: TestModifierConstructor): void {
     registerModifier(this.clientRegistry, name, ModifierClass);
     registerModifier(this.serverRegistry, name, ModifierClass);

packages/@glimmer/integration-tests/lib/render-delegate.ts

@@ -41,7 +41,6 @@ export default interface RenderDelegate {
   registerPlugin(plugin: ASTPluginBuilder): void;
   registerHelper(name: string, helper: UserHelper): void;
   registerInternalHelper(name: string, helper: Helper): void;
-  registerPartial(name: string, content: string): void;
   registerModifier(name: string, klass: unknown): void;
   renderTemplate(
     template: string,

packages/@glimmer/integration-tests/lib/render-test.ts

@@ -80,10 +80,6 @@ export class RenderTest implements IRenderTest {
     this.delegate.registerModifier(name, ModifierClass);
   }
 
-  registerPartial(name: string, content: string): void {
-    this.delegate.registerPartial(name, content);
-  }
-
   registerComponent<K extends ComponentKind>(
     type: K,
     name: string,