tint: Optimize sem node lookup

Add a 'NodeID' to each ast::Node which is the sequentially allocated
index of the node. Use this in sem::Info to map the AST node to the
semantic node, instead of using a std::unordered_map.

Optimised very hot code by entirely eliminating map lookups, and
dramatically reducing cache misses (lookups are usually sequentually
ordered).

Timings running
'webgpu:shader,execution,expression,call,builtin,atan2:f32:inputSource="const";vectorize="_undef_"'
with dawn/node, using SwiftShader:

    Without change: 3.22647107s
    With change:    3.10578879s

Bug: tint:1613
Change-Id: I22ec48d933b2e5f9da04494bff4e979e6f7b1982
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/96140
Commit-Queue: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>

src/tint/BUILD.gn

@@ -287,6 +287,7 @@ libtint_source_set("libtint_core_all_src") {
     "ast/module.h",
     "ast/multisampled_texture.cc",
     "ast/multisampled_texture.h",
+    "ast/node_id.h",
     "ast/node.cc",
     "ast/node.h",
     "ast/override.cc",

src/tint/CMakeLists.txt

@@ -157,6 +157,7 @@ set(TINT_LIB_SRCS
   ast/module.h
   ast/multisampled_texture.cc
   ast/multisampled_texture.h
+  ast/node_id.h
   ast/node.cc
   ast/node.h
   ast/override.cc

src/tint/ast/alias.cc

@@ -20,8 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Alias);
 
 namespace tint::ast {
 
-Alias::Alias(ProgramID pid, const Source& src, const Symbol& n, const Type* subtype)
+Alias::Alias(ProgramID pid, NodeID nid, const Source& src, const Symbol& n, const Type* subtype)
-    : Base(pid, src, n), type(subtype) {
+    : Base(pid, nid, src, n), type(subtype) {
     TINT_ASSERT(AST, type);
 }
 

src/tint/ast/alias.h

@@ -26,10 +26,11 @@ class Alias final : public Castable<Alias, TypeDecl> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param name the symbol for the alias
     /// @param subtype the alias'd type
-    Alias(ProgramID pid, const Source& src, const Symbol& name, const Type* subtype);
+    Alias(ProgramID pid, NodeID nid, const Source& src, const Symbol& name, const Type* subtype);
     /// Move constructor
     Alias(Alias&&);
     /// Destructor

src/tint/ast/array.cc

@@ -38,11 +38,12 @@ std::string SizeExprToString(const Expression* size, const SymbolTable& symbols)
 }  // namespace
 
 Array::Array(ProgramID pid,
+             NodeID nid,
              const Source& src,
              const Type* subtype,
              const Expression* cnt,
              AttributeList attrs)
-    : Base(pid, src), type(subtype), count(cnt), attributes(attrs) {}
+    : Base(pid, nid, src), type(subtype), count(cnt), attributes(attrs) {}
 
 Array::Array(Array&&) = default;
 

src/tint/ast/array.h

@@ -32,12 +32,14 @@ class Array final : public Castable<Array, Type> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param subtype the type of the array elements
     /// @param count the number of elements in the array. nullptr represents a
     /// runtime-sized array.
     /// @param attributes the array attributes
     Array(ProgramID pid,
+          NodeID nid,
           const Source& src,
           const Type* subtype,
           const Expression* count,

src/tint/ast/assignment_statement.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::AssignmentStatement);
 namespace tint::ast {
 
 AssignmentStatement::AssignmentStatement(ProgramID pid,
+                                         NodeID nid,
                                          const Source& src,
                                          const Expression* l,
                                          const Expression* r)
-    : Base(pid, src), lhs(l), rhs(r) {
+    : Base(pid, nid, src), lhs(l), rhs(r) {
     TINT_ASSERT(AST, lhs);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, lhs, program_id);
     TINT_ASSERT(AST, rhs);

src/tint/ast/assignment_statement.h

@@ -24,11 +24,13 @@ namespace tint::ast {
 class AssignmentStatement final : public Castable<AssignmentStatement, Statement> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the assignment statement source
     /// @param lhs the left side of the expression
     /// @param rhs the right side of the expression
-    AssignmentStatement(ProgramID program_id,
+    AssignmentStatement(ProgramID pid,
+                        NodeID nid,
                         const Source& source,
                         const Expression* lhs,
                         const Expression* rhs);

src/tint/ast/ast_type.cc

@@ -30,7 +30,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Type);
 
 namespace tint::ast {
 
-Type::Type(ProgramID pid, const Source& src) : Base(pid, src) {}
+Type::Type(ProgramID pid, NodeID nid, const Source& src) : Base(pid, nid, src) {}
 
 Type::Type(Type&&) = default;
 

src/tint/ast/atomic.cc

@@ -20,8 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Atomic);
 
 namespace tint::ast {
 
-Atomic::Atomic(ProgramID pid, const Source& src, const Type* const subtype)
+Atomic::Atomic(ProgramID pid, NodeID nid, const Source& src, const Type* const subtype)
-    : Base(pid, src), type(subtype) {}
+    : Base(pid, nid, src), type(subtype) {}
 
 std::string Atomic::FriendlyName(const SymbolTable& symbols) const {
     std::ostringstream out;

src/tint/ast/atomic.h

@@ -26,9 +26,10 @@ class Atomic final : public Castable<Atomic, Type> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param subtype the pointee type
-    Atomic(ProgramID pid, const Source& src, const Type* const subtype);
+    Atomic(ProgramID pid, NodeID nid, const Source& src, const Type* const subtype);
     /// Move constructor
     Atomic(Atomic&&);
     ~Atomic() override;

src/tint/ast/attribute.h

@@ -33,8 +33,9 @@ class Attribute : public Castable<Attribute, Node> {
   protected:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    Attribute(ProgramID pid, const Source& src) : Base(pid, src) {}
+    Attribute(ProgramID pid, NodeID nid, const Source& src) : Base(pid, nid, src) {}
 };
 
 /// A list of attributes

src/tint/ast/binary_expression.cc

@@ -21,11 +21,12 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BinaryExpression);
 namespace tint::ast {
 
 BinaryExpression::BinaryExpression(ProgramID pid,
+                                   NodeID nid,
                                    const Source& src,
                                    BinaryOp o,
                                    const Expression* l,
                                    const Expression* r)
-    : Base(pid, src), op(o), lhs(l), rhs(r) {
+    : Base(pid, nid, src), op(o), lhs(l), rhs(r) {
     TINT_ASSERT(AST, lhs);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, lhs, program_id);
     TINT_ASSERT(AST, rhs);

src/tint/ast/binary_expression.h

@@ -46,12 +46,14 @@ enum class BinaryOp {
 class BinaryExpression final : public Castable<BinaryExpression, Expression> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the binary expression source
     /// @param op the operation type
     /// @param lhs the left side of the expression
     /// @param rhs the right side of the expression
-    BinaryExpression(ProgramID program_id,
+    BinaryExpression(ProgramID pid,
+                     NodeID nid,
                      const Source& source,
                      BinaryOp op,
                      const Expression* lhs,

src/tint/ast/binding_attribute.cc

@@ -22,8 +22,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BindingAttribute);
 
 namespace tint::ast {
 
-BindingAttribute::BindingAttribute(ProgramID pid, const Source& src, uint32_t val)
+BindingAttribute::BindingAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t val)
-    : Base(pid, src), value(val) {}
+    : Base(pid, nid, src), value(val) {}
 
 BindingAttribute::~BindingAttribute() = default;
 

src/tint/ast/binding_attribute.h

@@ -26,9 +26,10 @@ class BindingAttribute final : public Castable<BindingAttribute, Attribute> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param value the binding value
-    BindingAttribute(ProgramID pid, const Source& src, uint32_t value);
+    BindingAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t value);
     ~BindingAttribute() override;
 
     /// @returns the WGSL name for the attribute

src/tint/ast/bitcast_expression.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BitcastExpression);
 namespace tint::ast {
 
 BitcastExpression::BitcastExpression(ProgramID pid,
+                                     NodeID nid,
                                      const Source& src,
                                      const Type* t,
                                      const Expression* e)
-    : Base(pid, src), type(t), expr(e) {
+    : Base(pid, nid, src), type(t), expr(e) {
     TINT_ASSERT(AST, type);
     TINT_ASSERT(AST, expr);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, expr, program_id);

src/tint/ast/bitcast_expression.h

@@ -28,11 +28,13 @@ namespace tint::ast {
 class BitcastExpression final : public Castable<BitcastExpression, Expression> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the bitcast expression source
     /// @param type the type
     /// @param expr the expr
-    BitcastExpression(ProgramID program_id,
+    BitcastExpression(ProgramID pid,
+                      NodeID nid,
                       const Source& source,
                       const Type* type,
                       const Expression* expr);

src/tint/ast/block_statement.cc

@@ -20,8 +20,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BlockStatement);
 
 namespace tint::ast {
 
-BlockStatement::BlockStatement(ProgramID pid, const Source& src, const StatementList& stmts)
+BlockStatement::BlockStatement(ProgramID pid,
-    : Base(pid, src), statements(std::move(stmts)) {
+                               NodeID nid,
+                               const Source& src,
+                               const StatementList& stmts)
+    : Base(pid, nid, src), statements(std::move(stmts)) {
     for (auto* stmt : statements) {
         TINT_ASSERT(AST, stmt);
         TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, stmt, program_id);

src/tint/ast/block_statement.h

@@ -25,10 +25,14 @@ namespace tint::ast {
 class BlockStatement final : public Castable<BlockStatement, Statement> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the block statement source
     /// @param statements the statements
-    BlockStatement(ProgramID program_id, const Source& source, const StatementList& statements);
+    BlockStatement(ProgramID pid,
+                   NodeID nid,
+                   const Source& source,
+                   const StatementList& statements);
     /// Move constructor
     BlockStatement(BlockStatement&&);
     ~BlockStatement() override;

src/tint/ast/bool.cc

@@ -20,7 +20,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Bool);
 
 namespace tint::ast {
 
-Bool::Bool(ProgramID pid, const Source& src) : Base(pid, src) {}
+Bool::Bool(ProgramID pid, NodeID nid, const Source& src) : Base(pid, nid, src) {}
 
 Bool::Bool(Bool&&) = default;
 

src/tint/ast/bool.h

@@ -32,8 +32,9 @@ class Bool final : public Castable<Bool, Type> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    Bool(ProgramID pid, const Source& src);
+    Bool(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     Bool(Bool&&);
     ~Bool() override;

src/tint/ast/bool_literal_expression.cc

@@ -20,8 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BoolLiteralExpression);
 
 namespace tint::ast {
 
-BoolLiteralExpression::BoolLiteralExpression(ProgramID pid, const Source& src, bool val)
+BoolLiteralExpression::BoolLiteralExpression(ProgramID pid, NodeID nid, const Source& src, bool val)
-    : Base(pid, src), value(val) {}
+    : Base(pid, nid, src), value(val) {}
 
 BoolLiteralExpression::~BoolLiteralExpression() = default;
 

src/tint/ast/bool_literal_expression.h

@@ -26,9 +26,10 @@ class BoolLiteralExpression final : public Castable<BoolLiteralExpression, Liter
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param value the bool literals value
-    BoolLiteralExpression(ProgramID pid, const Source& src, bool value);
+    BoolLiteralExpression(ProgramID pid, NodeID nid, const Source& src, bool value);
     ~BoolLiteralExpression() override;
 
     /// Clones this node and all transitive child nodes using the `CloneContext`

src/tint/ast/break_statement.cc

@@ -20,7 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BreakStatement);
 
 namespace tint::ast {
 
-BreakStatement::BreakStatement(ProgramID pid, const Source& src) : Base(pid, src) {}
+BreakStatement::BreakStatement(ProgramID pid, NodeID nid, const Source& src)
+    : Base(pid, nid, src) {}
 
 BreakStatement::BreakStatement(BreakStatement&&) = default;
 

src/tint/ast/break_statement.h

@@ -24,8 +24,9 @@ class BreakStatement final : public Castable<BreakStatement, Statement> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    BreakStatement(ProgramID pid, const Source& src);
+    BreakStatement(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     BreakStatement(BreakStatement&&);
     ~BreakStatement() override;

src/tint/ast/builtin_attribute.cc

@@ -22,8 +22,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BuiltinAttribute);
 
 namespace tint::ast {
 
-BuiltinAttribute::BuiltinAttribute(ProgramID pid, const Source& src, Builtin b)
+BuiltinAttribute::BuiltinAttribute(ProgramID pid, NodeID nid, const Source& src, Builtin b)
-    : Base(pid, src), builtin(b) {}
+    : Base(pid, nid, src), builtin(b) {}
 
 BuiltinAttribute::~BuiltinAttribute() = default;
 

src/tint/ast/builtin_attribute.h

@@ -27,9 +27,10 @@ class BuiltinAttribute final : public Castable<BuiltinAttribute, Attribute> {
   public:
     /// constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param builtin the builtin value
-    BuiltinAttribute(ProgramID pid, const Source& src, Builtin builtin);
+    BuiltinAttribute(ProgramID pid, NodeID nid, const Source& src, Builtin builtin);
     ~BuiltinAttribute() override;
 
     /// @returns the WGSL name for the attribute

src/tint/ast/call_expression.cc

@@ -34,10 +34,11 @@ CallExpression::Target ToTarget(const Type* type) {
 }  // namespace
 
 CallExpression::CallExpression(ProgramID pid,
+                               NodeID nid,
                                const Source& src,
                                const IdentifierExpression* name,
                                ExpressionList a)
-    : Base(pid, src), target(ToTarget(name)), args(a) {
+    : Base(pid, nid, src), target(ToTarget(name)), args(a) {
     TINT_ASSERT(AST, name);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, name, program_id);
     for (auto* arg : args) {
@@ -46,8 +47,12 @@ CallExpression::CallExpression(ProgramID pid,
     }
 }
 
-CallExpression::CallExpression(ProgramID pid, const Source& src, const Type* type, ExpressionList a)
+CallExpression::CallExpression(ProgramID pid,
-    : Base(pid, src), target(ToTarget(type)), args(a) {
+                               NodeID nid,
+                               const Source& src,
+                               const Type* type,
+                               ExpressionList a)
+    : Base(pid, nid, src), target(ToTarget(type)), args(a) {
     TINT_ASSERT(AST, type);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, type, program_id);
     for (auto* arg : args) {

src/tint/ast/call_expression.h

@@ -33,21 +33,25 @@ namespace tint::ast {
 class CallExpression final : public Castable<CallExpression, Expression> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the call expression source
     /// @param name the function or type name
     /// @param args the arguments
-    CallExpression(ProgramID program_id,
+    CallExpression(ProgramID pid,
+                   NodeID nid,
                    const Source& source,
                    const IdentifierExpression* name,
                    ExpressionList args);
 
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the call expression source
     /// @param type the type
     /// @param args the arguments
-    CallExpression(ProgramID program_id,
+    CallExpression(ProgramID pid,
+                   NodeID nid,
                    const Source& source,
                    const Type* type,
                    ExpressionList args);

src/tint/ast/call_statement.cc

@@ -20,8 +20,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::CallStatement);
 
 namespace tint::ast {
 
-CallStatement::CallStatement(ProgramID pid, const Source& src, const CallExpression* call)
+CallStatement::CallStatement(ProgramID pid,
-    : Base(pid, src), expr(call) {
+                             NodeID nid,
+                             const Source& src,
+                             const CallExpression* call)
+    : Base(pid, nid, src), expr(call) {
     TINT_ASSERT(AST, expr);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, expr, program_id);
 }

src/tint/ast/call_statement.h

@@ -25,9 +25,10 @@ class CallStatement final : public Castable<CallStatement, Statement> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node for the statement
     /// @param call the function
-    CallStatement(ProgramID pid, const Source& src, const CallExpression* call);
+    CallStatement(ProgramID pid, NodeID nid, const Source& src, const CallExpression* call);
     /// Move constructor
     CallStatement(CallStatement&&);
     ~CallStatement() override;

src/tint/ast/case_statement.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::CaseStatement);
 namespace tint::ast {
 
 CaseStatement::CaseStatement(ProgramID pid,
+                             NodeID nid,
                              const Source& src,
                              CaseSelectorList s,
                              const BlockStatement* b)
-    : Base(pid, src), selectors(s), body(b) {
+    : Base(pid, nid, src), selectors(s), body(b) {
     TINT_ASSERT(AST, body);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, body, program_id);
     for (auto* selector : selectors) {

src/tint/ast/case_statement.h

@@ -30,10 +30,12 @@ class CaseStatement final : public Castable<CaseStatement, Statement> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param selectors the case selectors
     /// @param body the case body
     CaseStatement(ProgramID pid,
+                  NodeID nid,
                   const Source& src,
                   CaseSelectorList selectors,
                   const BlockStatement* body);

src/tint/ast/compound_assignment_statement.cc

@@ -21,11 +21,12 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::CompoundAssignmentStatement);
 namespace tint::ast {
 
 CompoundAssignmentStatement::CompoundAssignmentStatement(ProgramID pid,
+                                                         NodeID nid,
                                                          const Source& src,
                                                          const Expression* l,
                                                          const Expression* r,
                                                          BinaryOp o)
-    : Base(pid, src), lhs(l), rhs(r), op(o) {
+    : Base(pid, nid, src), lhs(l), rhs(r), op(o) {
     TINT_ASSERT(AST, lhs);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, lhs, program_id);
     TINT_ASSERT(AST, rhs);

src/tint/ast/compound_assignment_statement.h

@@ -25,12 +25,14 @@ namespace tint::ast {
 class CompoundAssignmentStatement final : public Castable<CompoundAssignmentStatement, Statement> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the compound assignment statement source
     /// @param lhs the left side of the expression
     /// @param rhs the right side of the expression
     /// @param op the binary operator
-    CompoundAssignmentStatement(ProgramID program_id,
+    CompoundAssignmentStatement(ProgramID pid,
+                                NodeID nid,
                                 const Source& source,
                                 const Expression* lhs,
                                 const Expression* rhs,

src/tint/ast/const.cc

@@ -21,12 +21,13 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Const);
 namespace tint::ast {
 
 Const::Const(ProgramID pid,
+             NodeID nid,
              const Source& src,
              const Symbol& sym,
              const ast::Type* ty,
              const Expression* ctor,
              AttributeList attrs)
-    : Base(pid, src, sym, ty, ctor, attrs) {
+    : Base(pid, nid, src, sym, ty, ctor, attrs) {
     TINT_ASSERT(AST, ctor != nullptr);
 }
 

src/tint/ast/const.h

@@ -33,13 +33,15 @@ namespace tint::ast {
 class Const final : public Castable<Const, Variable> {
   public:
     /// Create a 'const' creation-time value variable.
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the variable source
     /// @param sym the variable symbol
     /// @param type the declared variable type
     /// @param constructor the constructor expression. Must not be nullptr.
     /// @param attributes the variable attributes
-    Const(ProgramID program_id,
+    Const(ProgramID pid,
+          NodeID nid,
           const Source& source,
           const Symbol& sym,
           const ast::Type* type,

src/tint/ast/continue_statement.cc

@@ -20,7 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::ContinueStatement);
 
 namespace tint::ast {
 
-ContinueStatement::ContinueStatement(ProgramID pid, const Source& src) : Base(pid, src) {}
+ContinueStatement::ContinueStatement(ProgramID pid, NodeID nid, const Source& src)
+    : Base(pid, nid, src) {}
 
 ContinueStatement::ContinueStatement(ContinueStatement&&) = default;
 

src/tint/ast/continue_statement.h

@@ -24,8 +24,9 @@ class ContinueStatement final : public Castable<ContinueStatement, Statement> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    ContinueStatement(ProgramID pid, const Source& src);
+    ContinueStatement(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     ContinueStatement(ContinueStatement&&);
     ~ContinueStatement() override;

src/tint/ast/depth_multisampled_texture.cc

@@ -28,9 +28,10 @@ bool IsValidDepthDimension(TextureDimension dim) {
 }  // namespace
 
 DepthMultisampledTexture::DepthMultisampledTexture(ProgramID pid,
+                                                   NodeID nid,
                                                    const Source& src,
                                                    TextureDimension d)
-    : Base(pid, src, d) {
+    : Base(pid, nid, src, d) {
     TINT_ASSERT(AST, IsValidDepthDimension(dim));
 }
 

src/tint/ast/depth_multisampled_texture.h

@@ -26,9 +26,10 @@ class DepthMultisampledTexture final : public Castable<DepthMultisampledTexture,
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param dim the dimensionality of the texture
-    DepthMultisampledTexture(ProgramID pid, const Source& src, TextureDimension dim);
+    DepthMultisampledTexture(ProgramID pid, NodeID nid, const Source& src, TextureDimension dim);
     /// Move constructor
     DepthMultisampledTexture(DepthMultisampledTexture&&);
     ~DepthMultisampledTexture() override;

src/tint/ast/depth_texture.cc

@@ -28,8 +28,8 @@ bool IsValidDepthDimension(TextureDimension dim) {
 
 }  // namespace
 
-DepthTexture::DepthTexture(ProgramID pid, const Source& src, TextureDimension d)
+DepthTexture::DepthTexture(ProgramID pid, NodeID nid, const Source& src, TextureDimension d)
-    : Base(pid, src, d) {
+    : Base(pid, nid, src, d) {
     TINT_ASSERT(AST, IsValidDepthDimension(dim));
 }
 

src/tint/ast/depth_texture.h

@@ -26,9 +26,10 @@ class DepthTexture final : public Castable<DepthTexture, Texture> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param dim the dimensionality of the texture
-    DepthTexture(ProgramID pid, const Source& src, TextureDimension dim);
+    DepthTexture(ProgramID pid, NodeID nid, const Source& src, TextureDimension dim);
     /// Move constructor
     DepthTexture(DepthTexture&&);
     ~DepthTexture() override;

src/tint/ast/disable_validation_attribute.cc

@@ -20,8 +20,10 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::DisableValidationAttribute);
 
 namespace tint::ast {
 
-DisableValidationAttribute::DisableValidationAttribute(ProgramID pid, DisabledValidation val)
+DisableValidationAttribute::DisableValidationAttribute(ProgramID pid,
-    : Base(pid), validation(val) {}
+                                                       NodeID nid,
+                                                       DisabledValidation val)
+    : Base(pid, nid), validation(val) {}
 
 DisableValidationAttribute::~DisableValidationAttribute() = default;
 
@@ -46,7 +48,8 @@ std::string DisableValidationAttribute::InternalName() const {
 }
 
 const DisableValidationAttribute* DisableValidationAttribute::Clone(CloneContext* ctx) const {
-    return ctx->dst->ASTNodes().Create<DisableValidationAttribute>(ctx->dst->ID(), validation);
+    return ctx->dst->ASTNodes().Create<DisableValidationAttribute>(
+        ctx->dst->ID(), ctx->dst->AllocateNodeID(), validation);
 }
 
 }  // namespace tint::ast

src/tint/ast/disable_validation_attribute.h

@@ -51,9 +51,10 @@ class DisableValidationAttribute final
     : public Castable<DisableValidationAttribute, InternalAttribute> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param validation the validation to disable
-    explicit DisableValidationAttribute(ProgramID program_id, DisabledValidation validation);
+    explicit DisableValidationAttribute(ProgramID pid, NodeID nid, DisabledValidation validation);
 
     /// Destructor
     ~DisableValidationAttribute() override;

src/tint/ast/discard_statement.cc

@@ -20,7 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::DiscardStatement);
 
 namespace tint::ast {
 
-DiscardStatement::DiscardStatement(ProgramID pid, const Source& src) : Base(pid, src) {}
+DiscardStatement::DiscardStatement(ProgramID pid, NodeID nid, const Source& src)
+    : Base(pid, nid, src) {}
 
 DiscardStatement::DiscardStatement(DiscardStatement&&) = default;
 

src/tint/ast/discard_statement.h

@@ -24,8 +24,9 @@ class DiscardStatement final : public Castable<DiscardStatement, Statement> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    DiscardStatement(ProgramID pid, const Source& src);
+    DiscardStatement(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     DiscardStatement(DiscardStatement&&);
     ~DiscardStatement() override;

src/tint/ast/enable.cc

@@ -21,7 +21,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Enable);
 
 namespace tint::ast {
 
-Enable::Enable(ProgramID pid, const Source& src, Extension ext) : Base(pid, src), extension(ext) {}
+Enable::Enable(ProgramID pid, NodeID nid, const Source& src, Extension ext)
+    : Base(pid, nid, src), extension(ext) {}
 
 Enable::Enable(Enable&&) = default;
 

src/tint/ast/enable.h

@@ -33,9 +33,10 @@ class Enable final : public Castable<Enable, Node> {
   public:
     /// Create a extension
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param ext the extension
-    Enable(ProgramID pid, const Source& src, Extension ext);
+    Enable(ProgramID pid, NodeID nid, const Source& src, Extension ext);
     /// Move constructor
     Enable(Enable&&);
 

src/tint/ast/expression.cc

@@ -21,7 +21,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Expression);
 
 namespace tint::ast {
 
-Expression::Expression(ProgramID pid, const Source& src) : Base(pid, src) {}
+Expression::Expression(ProgramID pid, NodeID nid, const Source& src) : Base(pid, nid, src) {}
 
 Expression::Expression(Expression&&) = default;
 

src/tint/ast/expression.h

@@ -31,8 +31,9 @@ class Expression : public Castable<Expression, Node> {
   protected:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    Expression(ProgramID pid, const Source& src);
+    Expression(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     Expression(Expression&&);
 };

src/tint/ast/external_texture.cc

@@ -21,8 +21,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::ExternalTexture);
 namespace tint::ast {
 
 // ExternalTexture::ExternalTexture() : Base(ast::TextureDimension::k2d) {}
-ExternalTexture::ExternalTexture(ProgramID pid, const Source& src)
+ExternalTexture::ExternalTexture(ProgramID pid, NodeID nid, const Source& src)
-    : Base(pid, src, ast::TextureDimension::k2d) {}
+    : Base(pid, nid, src, ast::TextureDimension::k2d) {}
 
 ExternalTexture::ExternalTexture(ExternalTexture&&) = default;
 

src/tint/ast/external_texture.h

@@ -26,8 +26,9 @@ class ExternalTexture final : public Castable<ExternalTexture, Texture> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    ExternalTexture(ProgramID pid, const Source& src);
+    ExternalTexture(ProgramID pid, NodeID nid, const Source& src);
 
     /// Move constructor
     ExternalTexture(ExternalTexture&&);

src/tint/ast/f16.cc

@@ -20,7 +20,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::F16);
 
 namespace tint::ast {
 
-F16::F16(ProgramID pid, const Source& src) : Base(pid, src) {}
+F16::F16(ProgramID pid, NodeID nid, const Source& src) : Base(pid, nid, src) {}
 
 F16::F16(F16&&) = default;
 

src/tint/ast/f16.h

@@ -26,8 +26,9 @@ class F16 : public Castable<F16, Type> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    F16(ProgramID pid, const Source& src);
+    F16(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     F16(F16&&);
     ~F16() override;

src/tint/ast/f32.cc

@@ -20,7 +20,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::F32);
 
 namespace tint::ast {
 
-F32::F32(ProgramID pid, const Source& src) : Base(pid, src) {}
+F32::F32(ProgramID pid, NodeID nid, const Source& src) : Base(pid, nid, src) {}
 
 F32::F32(F32&&) = default;
 

src/tint/ast/f32.h

@@ -26,8 +26,9 @@ class F32 final : public Castable<F32, Type> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    F32(ProgramID pid, const Source& src);
+    F32(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     F32(F32&&);
     ~F32() override;

src/tint/ast/fallthrough_statement.cc

@@ -20,7 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::FallthroughStatement);
 
 namespace tint::ast {
 
-FallthroughStatement::FallthroughStatement(ProgramID pid, const Source& src) : Base(pid, src) {}
+FallthroughStatement::FallthroughStatement(ProgramID pid, NodeID nid, const Source& src)
+    : Base(pid, nid, src) {}
 
 FallthroughStatement::FallthroughStatement(FallthroughStatement&&) = default;
 

src/tint/ast/fallthrough_statement.h

@@ -24,8 +24,9 @@ class FallthroughStatement final : public Castable<FallthroughStatement, Stateme
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    FallthroughStatement(ProgramID pid, const Source& src);
+    FallthroughStatement(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     FallthroughStatement(FallthroughStatement&&);
     ~FallthroughStatement() override;

src/tint/ast/float_literal_expression.cc

@@ -23,10 +23,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::FloatLiteralExpression);
 namespace tint::ast {
 
 FloatLiteralExpression::FloatLiteralExpression(ProgramID pid,
+                                               NodeID nid,
                                                const Source& src,
                                                double val,
                                                Suffix suf)
-    : Base(pid, src), value(val), suffix(suf) {}
+    : Base(pid, nid, src), value(val), suffix(suf) {}
 
 FloatLiteralExpression::~FloatLiteralExpression() = default;
 

src/tint/ast/float_literal_expression.h

@@ -36,10 +36,11 @@ class FloatLiteralExpression final : public Castable<FloatLiteralExpression, Lit
 
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param val the literal value
     /// @param suf the literal suffix
-    FloatLiteralExpression(ProgramID pid, const Source& src, double val, Suffix suf);
+    FloatLiteralExpression(ProgramID pid, NodeID nid, const Source& src, double val, Suffix suf);
     ~FloatLiteralExpression() override;
 
     /// Clones this node and all transitive child nodes using the `CloneContext`

src/tint/ast/for_loop_statement.cc

@@ -21,12 +21,13 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::ForLoopStatement);
 namespace tint::ast {
 
 ForLoopStatement::ForLoopStatement(ProgramID pid,
+                                   NodeID nid,
                                    const Source& src,
                                    const Statement* init,
                                    const Expression* cond,
                                    const Statement* cont,
                                    const BlockStatement* b)
-    : Base(pid, src), initializer(init), condition(cond), continuing(cont), body(b) {
+    : Base(pid, nid, src), initializer(init), condition(cond), continuing(cont), body(b) {
     TINT_ASSERT(AST, body);
 
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, initializer, program_id);

src/tint/ast/for_loop_statement.h

@@ -25,14 +25,16 @@ class Expression;
 class ForLoopStatement final : public Castable<ForLoopStatement, Statement> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the for loop statement source
     /// @param initializer the optional loop initializer statement
     /// @param condition the optional loop condition expression
     /// @param continuing the optional continuing statement
     /// @param body the loop body
-    ForLoopStatement(ProgramID program_id,
+    ForLoopStatement(ProgramID pid,
-                     Source const& source,
+                     NodeID nid,
+                     const Source& source,
                      const Statement* initializer,
                      const Expression* condition,
                      const Statement* continuing,

src/tint/ast/function.cc

@@ -23,6 +23,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Function);
 namespace tint::ast {
 
 Function::Function(ProgramID pid,
+                   NodeID nid,
                    const Source& src,
                    Symbol sym,
                    ParameterList parameters,
@@ -30,7 +31,7 @@ Function::Function(ProgramID pid,
                    const BlockStatement* b,
                    AttributeList attrs,
                    AttributeList return_type_attrs)
-    : Base(pid, src),
+    : Base(pid, nid, src),
       symbol(sym),
       params(std::move(parameters)),
       return_type(return_ty),

src/tint/ast/function.h

@@ -35,7 +35,8 @@ namespace tint::ast {
 class Function final : public Castable<Function, Node> {
   public:
     /// Create a function
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the variable source
     /// @param symbol the function symbol
     /// @param params the function parameters
@@ -43,7 +44,8 @@ class Function final : public Castable<Function, Node> {
     /// @param body the function body
     /// @param attributes the function attributes
     /// @param return_type_attributes the return type attributes
-    Function(ProgramID program_id,
+    Function(ProgramID pid,
+             NodeID nid,
              const Source& source,
              Symbol symbol,
              ParameterList params,

src/tint/ast/group_attribute.cc

@@ -22,8 +22,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::GroupAttribute);
 
 namespace tint::ast {
 
-GroupAttribute::GroupAttribute(ProgramID pid, const Source& src, uint32_t val)
+GroupAttribute::GroupAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t val)
-    : Base(pid, src), value(val) {}
+    : Base(pid, nid, src), value(val) {}
 
 GroupAttribute::~GroupAttribute() = default;
 

src/tint/ast/group_attribute.h

@@ -26,9 +26,10 @@ class GroupAttribute final : public Castable<GroupAttribute, Attribute> {
   public:
     /// constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param value the group value
-    GroupAttribute(ProgramID pid, const Source& src, uint32_t value);
+    GroupAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t value);
     ~GroupAttribute() override;
 
     /// @returns the WGSL name for the attribute

src/tint/ast/i32.cc

@@ -20,7 +20,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::I32);
 
 namespace tint::ast {
 
-I32::I32(ProgramID pid, const Source& src) : Base(pid, src) {}
+I32::I32(ProgramID pid, NodeID nid, const Source& src) : Base(pid, nid, src) {}
 
 I32::I32(I32&&) = default;
 

src/tint/ast/i32.h

@@ -26,8 +26,9 @@ class I32 final : public Castable<I32, Type> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    I32(ProgramID pid, const Source& src);
+    I32(ProgramID pid, NodeID nid, const Source& src);
     /// Move constructor
     I32(I32&&);
     ~I32() override;

src/tint/ast/id_attribute.cc

@@ -22,8 +22,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::IdAttribute);
 
 namespace tint::ast {
 
-IdAttribute::IdAttribute(ProgramID pid, const Source& src, uint32_t val)
+IdAttribute::IdAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t val)
-    : Base(pid, src), value(val) {}
+    : Base(pid, nid, src), value(val) {}
 
 IdAttribute::~IdAttribute() = default;
 

src/tint/ast/id_attribute.h

@@ -26,9 +26,10 @@ class IdAttribute final : public Castable<IdAttribute, Attribute> {
   public:
     /// Create an id attribute.
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param val the numeric id value
-    IdAttribute(ProgramID pid, const Source& src, uint32_t val);
+    IdAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t val);
     ~IdAttribute() override;
 
     /// @returns the WGSL name for the attribute

src/tint/ast/identifier_expression.cc

@@ -20,8 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::IdentifierExpression);
 
 namespace tint::ast {
 
-IdentifierExpression::IdentifierExpression(ProgramID pid, const Source& src, Symbol sym)
+IdentifierExpression::IdentifierExpression(ProgramID pid, NodeID nid, const Source& src, Symbol sym)
-    : Base(pid, src), symbol(sym) {
+    : Base(pid, nid, src), symbol(sym) {
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, symbol, program_id);
     TINT_ASSERT(AST, symbol.IsValid());
 }

src/tint/ast/identifier_expression.h

@@ -24,9 +24,10 @@ class IdentifierExpression final : public Castable<IdentifierExpression, Express
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param sym the symbol for the identifier
-    IdentifierExpression(ProgramID pid, const Source& src, Symbol sym);
+    IdentifierExpression(ProgramID pid, NodeID nid, const Source& src, Symbol sym);
     /// Move constructor
     IdentifierExpression(IdentifierExpression&&);
     ~IdentifierExpression() override;

src/tint/ast/if_statement.cc

@@ -21,11 +21,12 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::IfStatement);
 namespace tint::ast {
 
 IfStatement::IfStatement(ProgramID pid,
+                         NodeID nid,
                          const Source& src,
                          const Expression* cond,
                          const BlockStatement* b,
                          const Statement* else_stmt)
-    : Base(pid, src), condition(cond), body(b), else_statement(else_stmt) {
+    : Base(pid, nid, src), condition(cond), body(b), else_statement(else_stmt) {
     TINT_ASSERT(AST, condition);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, condition, program_id);
     TINT_ASSERT(AST, body);

src/tint/ast/if_statement.h

@@ -27,11 +27,13 @@ class IfStatement final : public Castable<IfStatement, Statement> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param condition the if condition
     /// @param body the if body
     /// @param else_stmt the else statement, or nullptr
     IfStatement(ProgramID pid,
+                NodeID nid,
                 const Source& src,
                 const Expression* condition,
                 const BlockStatement* body,

src/tint/ast/increment_decrement_statement.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::IncrementDecrementStatement);
 namespace tint::ast {
 
 IncrementDecrementStatement::IncrementDecrementStatement(ProgramID pid,
+                                                         NodeID nid,
                                                          const Source& src,
                                                          const Expression* l,
                                                          bool inc)
-    : Base(pid, src), lhs(l), increment(inc) {
+    : Base(pid, nid, src), lhs(l), increment(inc) {
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, lhs, program_id);
 }
 

src/tint/ast/increment_decrement_statement.h

@@ -25,10 +25,15 @@ class IncrementDecrementStatement final : public Castable<IncrementDecrementStat
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param lhs the LHS expression
     /// @param inc `true` for increment, `false` for decrement
-    IncrementDecrementStatement(ProgramID pid, const Source& src, const Expression* lhs, bool inc);
+    IncrementDecrementStatement(ProgramID pid,
+                                NodeID nid,
+                                const Source& src,
+                                const Expression* lhs,
+                                bool inc);
     /// Move constructor
     IncrementDecrementStatement(IncrementDecrementStatement&&);
     ~IncrementDecrementStatement() override;

src/tint/ast/index_accessor_expression.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::IndexAccessorExpression);
 namespace tint::ast {
 
 IndexAccessorExpression::IndexAccessorExpression(ProgramID pid,
+                                                 NodeID nid,
                                                  const Source& src,
                                                  const Expression* obj,
                                                  const Expression* idx)
-    : Base(pid, src), object(obj), index(idx) {
+    : Base(pid, nid, src), object(obj), index(idx) {
     TINT_ASSERT(AST, object);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, object, program_id);
     TINT_ASSERT(AST, idx);

src/tint/ast/index_accessor_expression.h

@@ -23,11 +23,13 @@ namespace tint::ast {
 class IndexAccessorExpression final : public Castable<IndexAccessorExpression, Expression> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the index accessor source
     /// @param obj the object
     /// @param idx the index expression
-    IndexAccessorExpression(ProgramID program_id,
+    IndexAccessorExpression(ProgramID pid,
+                            NodeID nid,
                             const Source& source,
                             const Expression* obj,
                             const Expression* idx);

src/tint/ast/int_literal_expression.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::IntLiteralExpression);
 namespace tint::ast {
 
 IntLiteralExpression::IntLiteralExpression(ProgramID pid,
+                                           NodeID nid,
                                            const Source& src,
                                            int64_t val,
                                            Suffix suf)
-    : Base(pid, src), value(val), suffix(suf) {}
+    : Base(pid, nid, src), value(val), suffix(suf) {}
 
 IntLiteralExpression::~IntLiteralExpression() = default;
 

src/tint/ast/int_literal_expression.h

@@ -34,10 +34,11 @@ class IntLiteralExpression : public Castable<IntLiteralExpression, LiteralExpres
 
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param val the literal value
     /// @param suf the literal suffix
-    IntLiteralExpression(ProgramID pid, const Source& src, int64_t val, Suffix suf);
+    IntLiteralExpression(ProgramID pid, NodeID nid, const Source& src, int64_t val, Suffix suf);
 
     ~IntLiteralExpression() override;
 

src/tint/ast/internal_attribute.cc

@@ -18,7 +18,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::InternalAttribute);
 
 namespace tint::ast {
 
-InternalAttribute::InternalAttribute(ProgramID pid) : Base(pid, Source{}) {}
+InternalAttribute::InternalAttribute(ProgramID pid, NodeID nid) : Base(pid, nid, Source{}) {}
 
 InternalAttribute::~InternalAttribute() = default;
 

src/tint/ast/internal_attribute.h

@@ -28,7 +28,8 @@ class InternalAttribute : public Castable<InternalAttribute, Attribute> {
   public:
     /// Constructor
     /// @param program_id the identifier of the program that owns this node
-    explicit InternalAttribute(ProgramID program_id);
+    /// @param nid the unique node identifier
+    explicit InternalAttribute(ProgramID program_id, NodeID nid);
 
     /// Destructor
     ~InternalAttribute() override;

src/tint/ast/interpolate_attribute.cc

@@ -23,10 +23,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::InterpolateAttribute);
 namespace tint::ast {
 
 InterpolateAttribute::InterpolateAttribute(ProgramID pid,
+                                           NodeID nid,
                                            const Source& src,
                                            InterpolationType ty,
                                            InterpolationSampling smpl)
-    : Base(pid, src), type(ty), sampling(smpl) {}
+    : Base(pid, nid, src), type(ty), sampling(smpl) {}
 
 InterpolateAttribute::~InterpolateAttribute() = default;
 

src/tint/ast/interpolate_attribute.h

@@ -33,10 +33,12 @@ class InterpolateAttribute final : public Castable<InterpolateAttribute, Attribu
   public:
     /// Create an interpolate attribute.
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param type the interpolation type
     /// @param sampling the interpolation sampling
     InterpolateAttribute(ProgramID pid,
+                         NodeID nid,
                          const Source& src,
                          InterpolationType type,
                          InterpolationSampling sampling);

src/tint/ast/invariant_attribute.cc

@@ -20,7 +20,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::InvariantAttribute);
 
 namespace tint::ast {
 
-InvariantAttribute::InvariantAttribute(ProgramID pid, const Source& src) : Base(pid, src) {}
+InvariantAttribute::InvariantAttribute(ProgramID pid, NodeID nid, const Source& src)
+    : Base(pid, nid, src) {}
 
 InvariantAttribute::~InvariantAttribute() = default;
 

src/tint/ast/invariant_attribute.h

@@ -26,8 +26,9 @@ class InvariantAttribute final : public Castable<InvariantAttribute, Attribute>
   public:
     /// constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
-    InvariantAttribute(ProgramID pid, const Source& src);
+    InvariantAttribute(ProgramID pid, NodeID nid, const Source& src);
     ~InvariantAttribute() override;
 
     /// @returns the WGSL name for the attribute

src/tint/ast/let.cc

@@ -21,12 +21,13 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Let);
 namespace tint::ast {
 
 Let::Let(ProgramID pid,
+         NodeID nid,
          const Source& src,
          const Symbol& sym,
          const ast::Type* ty,
          const Expression* ctor,
          AttributeList attrs)
-    : Base(pid, src, sym, ty, ctor, attrs) {
+    : Base(pid, nid, src, sym, ty, ctor, attrs) {
     TINT_ASSERT(AST, ctor != nullptr);
 }
 

src/tint/ast/let.h

@@ -30,13 +30,15 @@ namespace tint::ast {
 class Let final : public Castable<Let, Variable> {
   public:
     /// Create a 'let' variable
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the variable source
     /// @param sym the variable symbol
     /// @param type the declared variable type
     /// @param constructor the constructor expression
     /// @param attributes the variable attributes
-    Let(ProgramID program_id,
+    Let(ProgramID pid,
+        NodeID nid,
         const Source& source,
         const Symbol& sym,
         const ast::Type* type,

src/tint/ast/literal_expression.cc

@@ -18,7 +18,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::LiteralExpression);
 
 namespace tint::ast {
 
-LiteralExpression::LiteralExpression(ProgramID pid, const Source& src) : Base(pid, src) {}
+LiteralExpression::LiteralExpression(ProgramID pid, NodeID nid, const Source& src)
+    : Base(pid, nid, src) {}
 
 LiteralExpression::~LiteralExpression() = default;
 

src/tint/ast/literal_expression.h

@@ -29,8 +29,9 @@ class LiteralExpression : public Castable<LiteralExpression, Expression> {
   protected:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the input source
-    LiteralExpression(ProgramID pid, const Source& src);
+    LiteralExpression(ProgramID pid, NodeID nid, const Source& src);
 };
 
 }  // namespace tint::ast

src/tint/ast/location_attribute.cc

@@ -22,8 +22,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::LocationAttribute);
 
 namespace tint::ast {
 
-LocationAttribute::LocationAttribute(ProgramID pid, const Source& src, uint32_t val)
+LocationAttribute::LocationAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t val)
-    : Base(pid, src), value(val) {}
+    : Base(pid, nid, src), value(val) {}
 
 LocationAttribute::~LocationAttribute() = default;
 

src/tint/ast/location_attribute.h

@@ -26,9 +26,10 @@ class LocationAttribute final : public Castable<LocationAttribute, Attribute> {
   public:
     /// constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param value the location value
-    LocationAttribute(ProgramID pid, const Source& src, uint32_t value);
+    LocationAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t value);
     ~LocationAttribute() override;
 
     /// @returns the WGSL name for the attribute

src/tint/ast/loop_statement.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::LoopStatement);
 namespace tint::ast {
 
 LoopStatement::LoopStatement(ProgramID pid,
+                             NodeID nid,
                              const Source& src,
                              const BlockStatement* b,
                              const BlockStatement* cont)
-    : Base(pid, src), body(b), continuing(cont) {
+    : Base(pid, nid, src), body(b), continuing(cont) {
     TINT_ASSERT(AST, body);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, body, program_id);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, continuing, program_id);

src/tint/ast/loop_statement.h

@@ -23,11 +23,13 @@ namespace tint::ast {
 class LoopStatement final : public Castable<LoopStatement, Statement> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the loop statement source
     /// @param body the body statements
     /// @param continuing the continuing statements
-    LoopStatement(ProgramID program_id,
+    LoopStatement(ProgramID pid,
+                  NodeID nid,
                   const Source& source,
                   const BlockStatement* body,
                   const BlockStatement* continuing);

src/tint/ast/matrix.cc

@@ -20,8 +20,13 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::Matrix);
 
 namespace tint::ast {
 
-Matrix::Matrix(ProgramID pid, const Source& src, const Type* subtype, uint32_t r, uint32_t c)
+Matrix::Matrix(ProgramID pid,
-    : Base(pid, src), type(subtype), rows(r), columns(c) {
+               NodeID nid,
+               const Source& src,
+               const Type* subtype,
+               uint32_t r,
+               uint32_t c)
+    : Base(pid, nid, src), type(subtype), rows(r), columns(c) {
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, subtype, program_id);
     TINT_ASSERT(AST, rows > 1);
     TINT_ASSERT(AST, rows < 5);

src/tint/ast/matrix.h

@@ -26,13 +26,19 @@ class Matrix final : public Castable<Matrix, Type> {
   public:
     /// Constructor
     /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param src the source of this node
     /// @param subtype the declared type of the matrix components. May be null for
     ///        matrix constructors, where the element type will be inferred from
     ///        the constructor arguments
     /// @param rows the number of rows in the matrix
     /// @param columns the number of columns in the matrix
-    Matrix(ProgramID pid, const Source& src, const Type* subtype, uint32_t rows, uint32_t columns);
+    Matrix(ProgramID pid,
+           NodeID nid,
+           const Source& src,
+           const Type* subtype,
+           uint32_t rows,
+           uint32_t columns);
     /// Move constructor
     Matrix(Matrix&&);
     ~Matrix() override;

src/tint/ast/member_accessor_expression.cc

@@ -21,10 +21,11 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::MemberAccessorExpression);
 namespace tint::ast {
 
 MemberAccessorExpression::MemberAccessorExpression(ProgramID pid,
+                                                   NodeID nid,
                                                    const Source& src,
                                                    const Expression* str,
                                                    const IdentifierExpression* mem)
-    : Base(pid, src), structure(str), member(mem) {
+    : Base(pid, nid, src), structure(str), member(mem) {
     TINT_ASSERT(AST, structure);
     TINT_ASSERT_PROGRAM_IDS_EQUAL_IF_VALID(AST, structure, program_id);
     TINT_ASSERT(AST, member);

src/tint/ast/member_accessor_expression.h

@@ -23,11 +23,13 @@ namespace tint::ast {
 class MemberAccessorExpression final : public Castable<MemberAccessorExpression, Expression> {
   public:
     /// Constructor
-    /// @param program_id the identifier of the program that owns this node
+    /// @param pid the identifier of the program that owns this node
+    /// @param nid the unique node identifier
     /// @param source the member accessor expression source
     /// @param structure the structure
     /// @param member the member
-    MemberAccessorExpression(ProgramID program_id,
+    MemberAccessorExpression(ProgramID pid,
+                             NodeID nid,
                              const Source& source,
                              const Expression* structure,
                              const IdentifierExpression* member);