Rename extension from "html" to "markup" so it is more open to future

Author: imliam

Zend/tests/markup_operand_position_bc.phpt

@@ -80,7 +80,7 @@ $g = gen_lt_nospace(); $g->current(); $g->send("aaa");
 // Inverse direction: in operand position (after `=`, `(`, `,`, `=>`, `return`,
 // and parenthesized after `yield`) a "<tag" IS markup. Compile-time
 // classification only - never executed, so this parses even in builds where
-// the Html\ runtime classes are unavailable.
+// the Markup\ runtime classes are unavailable.
 function never_runs() {
     $x = <div/>;
     take(<p>hi</p>, <br/>);

Zend/zend_language_scanner.l

@@ -2142,7 +2142,7 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 
 <ST_MARKUP_TAG,ST_MARKUP_CLOSE>"$"{LABEL} {
 	/* A dynamic tag name (<$tag>…</$tag>): an ordinary variable whose runtime
-	 * value decides element vs component (see Html\render_dynamic). */
+	 * value decides element vs component (see Markup\render_dynamic). */
 	RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
 }
 

Zend/zend_markup.c

@@ -22,7 +22,7 @@
  *     attribute values;
  *   - AST lowering, called by the grammar actions
  *     (Zend/zend_language_parser.y) to turn markup elements into ordinary
- *     `new \Html\Element(...)` / `\Html\render_component(...)` ASTs, so no
+ *     `new \Markup\Element(...)` / `\Markup\render_component(...)` ASTs, so no
  *     new AST node kinds or zend_compile.c support are needed.
  *
  * The lexing mechanics themselves (scanner states, operand-position
@@ -257,8 +257,8 @@ zend_string *zend_markup_decode_entities(zend_string *str)
 }
 
 /* Native markup AST lowering.
- * Lower a markup element into an ordinary `new \Html\Element(tag, [], [children])`
- * (or `new \Html\Fragment([children])` when the tag name is empty) so no new AST
+ * Lower a markup element into an ordinary `new \Markup\Element(tag, [], [children])`
+ * (or `new \Markup\Fragment([children])` when the tag name is empty) so no new AST
  * node kind or zend_compile.c support is needed. `name` is the tag-name zval AST
  * or NULL for a fragment; `children` is a ZEND_AST_ARRAY of ZEND_AST_ARRAY_ELEM.
  *
@@ -277,7 +277,7 @@ static zend_ast *zend_ast_markup_fq_name(const char *name, size_t len)
  * uppercase, which is namespace-qualified (contains "\"), or which names a
  * static method via "::", dispatches as a component; anything else is a literal
  * HTML element. The single home for this rule: the compiler applies it to
- * static tag names here, and Html\render_dynamic applies it to a dynamic tag's
+ * static tag names here, and Markup\render_dynamic applies it to a dynamic tag's
  * runtime value (hence ZEND_API). */
 ZEND_API bool zend_markup_name_is_component(zend_string *tag)
 {
@@ -286,7 +286,7 @@ ZEND_API bool zend_markup_name_is_component(zend_string *tag)
 		|| strstr(ZSTR_VAL(tag), "::") != NULL;
 }
 
-/* Wrap a list of children in `new \Html\Fragment([children])`. Consumes (and, if
+/* Wrap a list of children in `new \Markup\Fragment([children])`. Consumes (and, if
  * NULL, creates) the children list. */
 static zend_ast *zend_ast_wrap_fragment(zend_ast *children)
 {
@@ -301,7 +301,7 @@ static zend_ast *zend_ast_wrap_fragment(zend_ast *children)
 		zend_ast_create_list(1, ZEND_AST_ARG_LIST, children));
 }
 
-/* Wrap a string AST in a `\Html\raw(...)` call (trusted passthrough). Used for
+/* Wrap a string AST in a `\Markup\raw(...)` call (trusted passthrough). Used for
  * `<!-- … -->` comments, which are emitted as literal HTML. */
 zend_ast *zend_ast_create_markup_raw(zend_ast *str)
 {
@@ -311,7 +311,7 @@ zend_ast *zend_ast_create_markup_raw(zend_ast *str)
 }
 
 /* Wrap a children list in
- * `new \Html\LazyFragment(fn() => new \Html\Fragment([children]))` (the
+ * `new \Markup\LazyFragment(fn() => new \Markup\Fragment([children]))` (the
  * `:lazy` directive). The arrow function defers building the child subtree -
  * and running any side effects in its interpolations - until the component
  * actually renders the slot, so a component that discards its body never
@@ -320,7 +320,7 @@ static zend_ast *zend_ast_wrap_lazy_fragment(zend_ast *children, uint32_t lineno
 {
 	zend_ast *frag = zend_ast_wrap_fragment(children);
 
-	/* fn() => new \Html\Fragment([...]) - an arrow function so its body
+	/* fn() => new \Markup\Fragment([...]) - an arrow function so its body
 	 * auto-captures by value whatever it references, exactly as a hand-written
 	 * one would; only the expression evaluation is deferred. */
 	zend_ast *params = zend_ast_create_list(0, ZEND_AST_PARAM_LIST);
@@ -361,19 +361,19 @@ static bool zend_markup_extract_lazy(zend_ast *attrs)
 }
 
 /* Lower a component tag (a capitalized or namespace-qualified name, or
- * "Class::method") into a call to \Html\render_component(component, props, slot)
+ * "Class::method") into a call to \Markup\render_component(component, props, slot)
  * Attributes become the props array and the body content becomes a
- * single \Html\Fragment passed as the slot (or a lazy \Html\LazyFragment when
+ * single \Markup\Fragment passed as the slot (or a lazy \Markup\LazyFragment when
  * the `:lazy` directive is present).
  *
  * Component resolution is two-stage, and every tag resolves through the *class*
  * name rules only: a bare/qualified tag lowers to ZEND_AST_CLASS_NAME (the
  * `Component::class` machinery), and a "Class::method" tag lowers the class
  * part the same way with "::method" appended - both honor `use` imports and
  * the current namespace, with a leading "\" fully qualified. The runtime then
- * resolves the name to a class implementing Html\Htmlable (instantiated) or a
- * public static method (called) - see PHP_FUNCTION(Html_render_component) in
- * ext/html/html.c.
+ * resolves the name to a class implementing Markup\Html (instantiated) or a
+ * public static method (called) - see PHP_FUNCTION(Markup_render_component) in
+ * ext/markup/markup.c.
  *
  * Plain *function* components are deliberately out of v1: a bare tag gives no
  * signal whether a class or a function is meant, and functions resolve through
@@ -419,7 +419,7 @@ static zend_ast *zend_ast_create_markup_component(zend_ast *name, zend_ast *attr
 	bool lazy = zend_markup_extract_lazy(attrs);
 
 	/* The body becomes a single slot Fragment, or null when there is no body.
-	 * With `:lazy` the fragment is wrapped in a deferred Html\LazyFragment. */
+	 * With `:lazy` the fragment is wrapped in a deferred Markup\LazyFragment. */
 	zend_ast *slot;
 	if (children != NULL && zend_ast_get_list(children)->children > 0) {
 		children->attr = ZEND_ARRAY_SYNTAX_SHORT;
@@ -540,7 +540,7 @@ zend_ast *zend_ast_create_markup_checked(zend_ast *open, zend_ast *attrs, zend_a
 		: zend_ast_create_markup_element(open, attrs, children);
 }
 
-/* Build the \Html\render_dynamic(tag_expr, attributes, children) call both
+/* Build the \Markup\render_dynamic(tag_expr, attributes, children) call both
  * dynamic-tag forms lower into. `tag_expr` is an already-built expression AST
  * producing the tag name; `lineno` is the opening-tag line (see
  * zend_ast_create_markup_element for why it is stamped explicitly). */
@@ -569,7 +569,7 @@ static zend_ast *zend_markup_dynamic_call(zend_ast *tag_expr, zend_ast *attrs, z
 }
 
 /* Lower a dynamic tag `<$tag …>…</$tag>` into a call to
- * \Html\render_dynamic($tag, attributes, children). The variable's runtime
+ * \Markup\render_dynamic($tag, attributes, children). The variable's runtime
  * value decides what a static tag name decides at compile time, by the same
  * classification rule (zend_markup_name_is_component); only classification
  * moves to runtime. `name` is the T_VARIABLE zval AST (without the "$"). */

Zend/zend_markup.h

@@ -23,27 +23,27 @@
 /* The fully-qualified names that Native Markup Expressions
  * lowers into. This is the single home for the markup-to-runtime vocabulary:
  * the parser (Zend/zend_language_parser.y) lowers markup expressions to exactly
- * these symbols, and the ext/html runtime registers exactly them (asserted at
- * MINIT, see PHP_MINIT_FUNCTION(html)).
+ * these symbols, and the ext/markup runtime registers exactly them (asserted at
+ * MINIT, see PHP_MINIT_FUNCTION(markup)).
  *
- * Renaming the markup namespace (e.g. the open `Html\` vs `PHP\Html\` question)
+ * Renaming the markup namespace (e.g. the open `Markup\` vs `PHP\Markup\` question)
  * is a one-line edit here rather than a hunt across the parser, stub, and
- * runtime. Keep in sync with ext/html/html.stub.php, which declares the classes
+ * runtime. Keep in sync with ext/markup/html.stub.php, which declares the classes
  * and functions these names refer to. */
 
-#define ZEND_MARKUP_ELEMENT_FQ        "Html\\Element"
-#define ZEND_MARKUP_FRAGMENT_FQ       "Html\\Fragment"
-#define ZEND_MARKUP_LAZY_FRAGMENT_FQ  "Html\\LazyFragment"
-#define ZEND_MARKUP_RAW_FQ            "Html\\raw"
-#define ZEND_MARKUP_COMPONENT_FQ      "Html\\render_component"
-#define ZEND_MARKUP_DYNAMIC_FQ        "Html\\render_dynamic"
+#define ZEND_MARKUP_ELEMENT_FQ        "Markup\\Element"
+#define ZEND_MARKUP_FRAGMENT_FQ       "Markup\\Fragment"
+#define ZEND_MARKUP_LAZY_FRAGMENT_FQ  "Markup\\LazyFragment"
+#define ZEND_MARKUP_RAW_FQ            "Markup\\raw"
+#define ZEND_MARKUP_COMPONENT_FQ      "Markup\\render_component"
+#define ZEND_MARKUP_DYNAMIC_FQ        "Markup\\render_dynamic"
 
 BEGIN_EXTERN_C()
 
 /* Element vs component classification: uppercase first character,
  * a "\", or a "::" dispatches as a component; anything else is a literal HTML
  * element. The single home for this rule - the compiler applies it to static
- * tag names, and Html\render_dynamic applies it to a dynamic tag's runtime
+ * tag names, and Markup\render_dynamic applies it to a dynamic tag's runtime
  * value, so `<$tag>` decides at runtime exactly what `<tag>` decides at
  * compile time. */
 ZEND_API bool zend_markup_name_is_component(zend_string *tag);