Revert "Merge pull request #1553 from patricklx/html-tag-split"

This reverts commit e934005, reversing
changes made to 648ce18.

packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts

@@ -14,7 +14,7 @@ import * as src from '../source/api';
 import { generateSyntaxError } from '../syntax-error';
 import traverse from '../traversal/traverse';
 import Walker from '../traversal/walker';
-import { appendChild, parseElementBlockParams, parseElementPartLocs } from '../utils';
+import { appendChild, parseElementBlockParams } from '../utils';
 import b from '../v1/parser-builders';
 import publicBuilder from '../v1/public-builders';
 import { HandlebarsNodeVisitors } from './handlebars-node-visitors';
@@ -135,21 +135,6 @@ export class TokenizerEventHandlers extends HandlebarsNodeVisitors {
       blockParams: [],
       loc,
     });
-    element.startTag = {
-      type: 'ElementStartNode',
-      value: name,
-      loc: loc,
-    };
-    element.nameNode = {
-      type: 'ElementNameNode',
-      value: name,
-      loc: loc
-        .withStart(this.source.offsetFor(loc.startPosition.line, loc.startPosition.column + 1))
-        .withEnd(
-          this.source.offsetFor(loc.startPosition.line, loc.startPosition.column + 1 + name.length)
-        ),
-    };
-    parseElementPartLocs(this.source, element);
     this.elementStack.push(element);
   }
 
@@ -158,12 +143,6 @@ export class TokenizerEventHandlers extends HandlebarsNodeVisitors {
 
     let element = this.elementStack.pop() as ASTv1.ElementNode;
 
-    element.endTag = {
-      type: 'ElementEndNode',
-      loc: tag.loc,
-      value: element.selfClosing ? '' : tag.name,
-    };
-
     this.validateEndTag(tag, element, isVoid);
     let parent = this.currentElement();
 

packages/@glimmer/syntax/lib/utils.ts

@@ -1,7 +1,6 @@
 import type { Nullable } from '@glimmer/interfaces';
 import { expect, unwrap } from '@glimmer/util';
 
-import type { src } from '..';
 import type * as ASTv1 from './v1/api';
 import type * as HBS from './v1/handlebars-ast';
 
@@ -21,26 +20,6 @@ export function parseElementBlockParams(element: ASTv1.ElementNode): void {
   if (params) element.blockParams = params;
 }
 
-export function parseElementPartLocs(code: src.Source, element: ASTv1.ElementNode) {
-  const elementRange = [element.loc.getStart().offset!, element.loc.getEnd().offset!] as [
-    number,
-    number,
-  ];
-  let start = elementRange[0];
-  let codeSlice = code.slice(...elementRange);
-  for (const part of element.parts) {
-    const idx = codeSlice.indexOf(part.value);
-    const range = [start + idx, 0] as [number, number];
-    range[1] = range[0] + part.value.length;
-    codeSlice = code.slice(range[1], elementRange[1]);
-    start = range[1];
-    part.loc = code.spanFor({
-      start: code.hbsPosFor(range[0])!,
-      end: code.hbsPosFor(range[1])!,
-    });
-  }
-}
-
 function parseBlockParams(element: ASTv1.ElementNode): Nullable<string[]> {
   let l = element.attributes.length;
   let attrNames = [];

packages/@glimmer/syntax/lib/v1/nodes-v1.ts

@@ -102,48 +102,9 @@ export interface MustacheCommentStatement extends BaseNode {
   value: string;
 }
 
-export interface ElementName {
-  type: 'ElementName';
-  name: string;
-  loc: src.SourceLocation;
-}
-
-export interface ElementStartNode extends BaseNode {
-  type: 'ElementStartNode';
-  value: string;
-}
-
-export interface ElementNameNode extends BaseNode {
-  type: 'ElementNameNode';
-  value: string;
-}
-
-export interface ElementEndNode extends BaseNode {
-  type: 'ElementEndNode';
-  value: string;
-}
-
-export interface ElementPartNode extends BaseNode {
-  type: 'ElementPartNode';
-  value: string;
-}
-
-/*
-  <Foo.bar.x attr='2'></Foo.bar.x>
-   ^-- ElementPartNode
-       ^-- ElementPartNode
-          ^- ElementPartNode
-   ^-------- ElementNameNode
-  ^------------------ ElementStartNode
-                      ^----------- ElementEndNode
- */
 export interface ElementNode extends BaseNode {
   type: 'ElementNode';
   tag: string;
-  nameNode: ElementNameNode;
-  startTag: ElementStartNode;
-  endTag: ElementEndNode;
-  parts: ElementPartNode[];
   selfClosing: boolean;
   attributes: AttrNode[];
   blockParams: string[];
@@ -285,7 +246,7 @@ export interface StripFlags {
   close: boolean;
 }
 
-export type SharedNodes = {
+export type Nodes = {
   CommentStatement: CommentStatement;
   MustacheCommentStatement: MustacheCommentStatement;
   TextNode: TextNode;
@@ -298,13 +259,6 @@ export type SharedNodes = {
   ElementModifierStatement: ElementModifierStatement;
   AttrNode: AttrNode;
   ConcatStatement: ConcatStatement;
-};
-
-export type Nodes = SharedNodes & {
-  ElementEndNode: ElementEndNode;
-  ElementStartNode: ElementStartNode;
-  ElementPartNode: ElementPartNode;
-  ElementNameNode: ElementNameNode;
   Template: Template;
   Block: Block;
   BlockStatement: BlockStatement;

packages/@glimmer/syntax/lib/v1/parser-builders.ts

@@ -163,21 +163,6 @@ class Builders {
     return {
       type: 'ElementNode',
       tag,
-      nameNode: {
-        type: 'ElementNameNode',
-        value: tag,
-      } as ASTv1.ElementNameNode,
-      startTag: {
-        type: 'ElementStartNode',
-        value: tag,
-      } as ASTv1.ElementStartNode,
-      endTag: {
-        type: 'ElementEndNode',
-        value: selfClosing ? '' : tag,
-      } as ASTv1.ElementEndNode,
-      parts: tag
-        .split('.')
-        .map((t) => ({ type: 'ElementPartNode', value: t }) as ASTv1.ElementPartNode),
       selfClosing: selfClosing,
       attributes: attrs || [],
       blockParams: blockParams || [],

packages/@glimmer/syntax/lib/v1/public-builders.ts

@@ -197,21 +197,6 @@ function buildElement(tag: TagDescriptor, options: BuildElementOptions = {}): AS
   return {
     type: 'ElementNode',
     tag: tagName,
-    nameNode: {
-      type: 'ElementNameNode',
-      value: tag,
-    } as ASTv1.ElementNameNode,
-    startTag: {
-      type: 'ElementStartNode',
-      value: tag,
-    } as ASTv1.ElementStartNode,
-    endTag: {
-      type: 'ElementEndNode',
-      value: selfClosing ? '' : tag,
-    } as ASTv1.ElementEndNode,
-    parts: tagName
-      .split('.')
-      .map((t) => ({ type: 'ElementPartNode', value: t }) as ASTv1.ElementPartNode),
     selfClosing: selfClosing,
     attributes: attrs || [],
     blockParams: blockParams || [],

packages/@glimmer/syntax/lib/v1/visitor-keys.ts

@@ -12,10 +12,6 @@ const visitorKeys = {
   CommentStatement: [],
   MustacheCommentStatement: [],
   ElementNode: ['attributes', 'modifiers', 'children', 'comments'],
-  ElementStartNode: [],
-  ElementPartNode: [],
-  ElementEndNode: [],
-  ElementNameNode: [],
   AttrNode: ['value'],
   TextNode: [],
 

packages/@glimmer/syntax/test/loc-node-test.ts

@@ -134,29 +134,6 @@ test('html elements', () => {
   }
 });
 
-test('html elements with paths', () => {
-  let ast = parse(`
-    <Foo as |bar|>
-      <bar.x.y class='bar'/>
-      <bar.x.y class='bar'></bar.x.y>
-    </Foo>
-  `);
-
-  let [, foo] = ast.body;
-  locEqual(foo, 2, 4, 5, 10, 'Foo element');
-  if (assertNodeType(foo, 'ElementNode')) {
-    locEqual(foo.startTag, 2, 4, 2, 18, 'Foo start tag');
-    locEqual(foo.nameNode, 2, 5, 2, 8, 'Foo name node');
-    locEqual(foo.endTag, 5, 4, 5, 10, 'Foo end tag');
-    let [, barSelfClosed] = foo.children;
-    if (assertNodeType(barSelfClosed, 'ElementNode')) {
-      locEqual(barSelfClosed.parts[0], 3, 7, 3, 10, 'bar.x.y bar part');
-      locEqual(barSelfClosed.parts[1], 3, 11, 3, 12, 'bar.x.y x part');
-      locEqual(barSelfClosed.parts[2], 3, 13, 3, 14, 'bar.x.y y part');
-    }
-  }
-});
-
 test('html elements with nested blocks', (assert) => {
   let ast = parse(`
     <div>

packages/@glimmer/syntax/test/parser-node-test.ts

@@ -266,17 +266,6 @@ test('Element modifiers', () => {
   );
 });
 
-test('Element paths', (assert) => {
-  let t = "<bar.x.y class='bar'></bar.x.y>";
-  const elem = element('bar.x.y', ['attrs', ['class', 'bar']]);
-  astEqual(t, b.template([elem]));
-  assert.strictEqual(elem.parts.length, 3);
-  assert.deepEqual(
-    elem.parts.map((p) => p.value),
-    ['bar', 'x', 'y']
-  );
-});
-
 test('Tokenizer: MustacheStatement encountered in beforeAttributeName state', () => {
   let t = '<input {{bar}}>';
   astEqual(t, b.template([element('input', ['modifiers', 'bar'])]));
@@ -902,22 +891,7 @@ export function element(tag: TagDescriptor, ...options: ElementParts[]): ASTv1.E
 
   return {
     type: 'ElementNode',
-    tag: tag,
-    nameNode: {
-      type: 'ElementNameNode',
-      value: tag,
-    } as ASTv1.ElementNameNode,
-    startTag: {
-      type: 'ElementStartNode',
-      value: tag,
-    } as ASTv1.ElementStartNode,
-    endTag: {
-      type: 'ElementEndNode',
-      value: selfClosing ? '' : tag,
-    } as ASTv1.ElementEndNode,
-    parts: tag
-      .split('.')
-      .map((t) => ({ type: 'ElementPartNode', value: t }) as ASTv1.ElementPartNode),
+    tag: tag || '',
     selfClosing: selfClosing,
     attributes: attrs || [],
     blockParams: blockParams || [],