diff --git a/packages/cxx-gen-ast/src/gen_ast_dump_cc.ts b/packages/cxx-gen-ast/src/gen_ast_dump_cc.ts
index 2cf480ec..b8f21ba6 100644
--- a/packages/cxx-gen-ast/src/gen_ast_dump_cc.ts
+++ b/packages/cxx-gen-ast/src/gen_ast_dump_cc.ts
@@ -105,7 +105,15 @@ export function gen_ast_dump_cc({ ast, output }: { ast: AST; output: string }) {
     nodes.forEach(({ name, base, members }) => {
       emit();
       emit(`void ASTPrinter::visit(${name}* ast) {`);
-      emit(`  out_ << std::format("{}\\n", "${astName(name)}");`);
+      if (base == "ExpressionAST") {
+        emit(`  out_ << "${astName(name)}";`);
+        emit(`  if (ast->type) {`);
+        emit(`    out_ << std::format(" [{} {}]", to_string(ast->valueCategory), to_string(ast->type));`);
+        emit(`  }`);
+        emit(`  out_ << "\\n";`);
+      } else {
+        emit(`  out_ << std::format("{}\\n", "${astName(name)}");`);
+      }
 
       const baseMembers = ast.baseMembers.get(base);
 
diff --git a/src/frontend/cxx/ast_printer.cc b/src/frontend/cxx/ast_printer.cc
index 28ec3f5c..c9a502fe 100644
--- a/src/frontend/cxx/ast_printer.cc
+++ b/src/frontend/cxx/ast_printer.cc
@@ -706,11 +706,21 @@ void ASTPrinter::visit(TryBlockStatementAST* ast) {
 }
 
 void ASTPrinter::visit(GeneratedLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "generated-literal-expression");
+  out_ << "generated-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
 }
 
 void ASTPrinter::visit(CharLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "char-literal-expression");
+  out_ << "char-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->literal) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -720,7 +730,12 @@ void ASTPrinter::visit(CharLiteralExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(BoolLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "bool-literal-expression");
+  out_ << "bool-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->isTrue) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -730,7 +745,12 @@ void ASTPrinter::visit(BoolLiteralExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(IntLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "int-literal-expression");
+  out_ << "int-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->literal) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -740,7 +760,12 @@ void ASTPrinter::visit(IntLiteralExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(FloatLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "float-literal-expression");
+  out_ << "float-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->literal) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -750,7 +775,12 @@ void ASTPrinter::visit(FloatLiteralExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(NullptrLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "nullptr-literal-expression");
+  out_ << "nullptr-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->literal != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -760,7 +790,12 @@ void ASTPrinter::visit(NullptrLiteralExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(StringLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "string-literal-expression");
+  out_ << "string-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->literal) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -770,7 +805,12 @@ void ASTPrinter::visit(StringLiteralExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(UserDefinedStringLiteralExpressionAST* ast) {
-  out_ << std::format("{}\n", "user-defined-string-literal-expression");
+  out_ << "user-defined-string-literal-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->literal) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -780,21 +820,41 @@ void ASTPrinter::visit(UserDefinedStringLiteralExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(ThisExpressionAST* ast) {
-  out_ << std::format("{}\n", "this-expression");
+  out_ << "this-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
 }
 
 void ASTPrinter::visit(NestedStatementExpressionAST* ast) {
-  out_ << std::format("{}\n", "nested-statement-expression");
+  out_ << "nested-statement-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->statement, "statement");
 }
 
 void ASTPrinter::visit(NestedExpressionAST* ast) {
-  out_ << std::format("{}\n", "nested-expression");
+  out_ << "nested-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(IdExpressionAST* ast) {
-  out_ << std::format("{}\n", "id-expression");
+  out_ << "id-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->isTemplateIntroduced) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -807,7 +867,12 @@ void ASTPrinter::visit(IdExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(LambdaExpressionAST* ast) {
-  out_ << std::format("{}\n", "lambda-expression");
+  out_ << "lambda-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->captureDefault != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -869,7 +934,12 @@ void ASTPrinter::visit(LambdaExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(FoldExpressionAST* ast) {
-  out_ << std::format("{}\n", "fold-expression");
+  out_ << "fold-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->op != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -887,7 +957,12 @@ void ASTPrinter::visit(FoldExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(RightFoldExpressionAST* ast) {
-  out_ << std::format("{}\n", "right-fold-expression");
+  out_ << "right-fold-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->op != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -898,7 +973,12 @@ void ASTPrinter::visit(RightFoldExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(LeftFoldExpressionAST* ast) {
-  out_ << std::format("{}\n", "left-fold-expression");
+  out_ << "left-fold-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->op != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -909,7 +989,12 @@ void ASTPrinter::visit(LeftFoldExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(RequiresExpressionAST* ast) {
-  out_ << std::format("{}\n", "requires-expression");
+  out_ << "requires-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->parameterDeclarationClause, "parameter-declaration-clause");
   if (ast->requirementList) {
     ++indent_;
@@ -923,19 +1008,34 @@ void ASTPrinter::visit(RequiresExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(VaArgExpressionAST* ast) {
-  out_ << std::format("{}\n", "va-arg-expression");
+  out_ << "va-arg-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
   accept(ast->typeId, "type-id");
 }
 
 void ASTPrinter::visit(SubscriptExpressionAST* ast) {
-  out_ << std::format("{}\n", "subscript-expression");
+  out_ << "subscript-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->baseExpression, "base-expression");
   accept(ast->indexExpression, "index-expression");
 }
 
 void ASTPrinter::visit(CallExpressionAST* ast) {
-  out_ << std::format("{}\n", "call-expression");
+  out_ << "call-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->baseExpression, "base-expression");
   if (ast->expressionList) {
     ++indent_;
@@ -949,7 +1049,12 @@ void ASTPrinter::visit(CallExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(TypeConstructionAST* ast) {
-  out_ << std::format("{}\n", "type-construction");
+  out_ << "type-construction";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeSpecifier, "type-specifier");
   if (ast->expressionList) {
     ++indent_;
@@ -963,13 +1068,23 @@ void ASTPrinter::visit(TypeConstructionAST* ast) {
 }
 
 void ASTPrinter::visit(BracedTypeConstructionAST* ast) {
-  out_ << std::format("{}\n", "braced-type-construction");
+  out_ << "braced-type-construction";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeSpecifier, "type-specifier");
   accept(ast->bracedInitList, "braced-init-list");
 }
 
 void ASTPrinter::visit(SpliceMemberExpressionAST* ast) {
-  out_ << std::format("{}\n", "splice-member-expression");
+  out_ << "splice-member-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->accessOp != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -988,7 +1103,12 @@ void ASTPrinter::visit(SpliceMemberExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(MemberExpressionAST* ast) {
-  out_ << std::format("{}\n", "member-expression");
+  out_ << "member-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->accessOp != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1008,7 +1128,12 @@ void ASTPrinter::visit(MemberExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(PostIncrExpressionAST* ast) {
-  out_ << std::format("{}\n", "post-incr-expression");
+  out_ << "post-incr-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->op != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1019,59 +1144,114 @@ void ASTPrinter::visit(PostIncrExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(CppCastExpressionAST* ast) {
-  out_ << std::format("{}\n", "cpp-cast-expression");
+  out_ << "cpp-cast-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(BuiltinBitCastExpressionAST* ast) {
-  out_ << std::format("{}\n", "builtin-bit-cast-expression");
+  out_ << "builtin-bit-cast-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(BuiltinOffsetofExpressionAST* ast) {
-  out_ << std::format("{}\n", "builtin-offsetof-expression");
+  out_ << "builtin-offsetof-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(TypeidExpressionAST* ast) {
-  out_ << std::format("{}\n", "typeid-expression");
+  out_ << "typeid-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(TypeidOfTypeExpressionAST* ast) {
-  out_ << std::format("{}\n", "typeid-of-type-expression");
+  out_ << "typeid-of-type-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
 }
 
 void ASTPrinter::visit(SpliceExpressionAST* ast) {
-  out_ << std::format("{}\n", "splice-expression");
+  out_ << "splice-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->splicer, "splicer");
 }
 
 void ASTPrinter::visit(GlobalScopeReflectExpressionAST* ast) {
-  out_ << std::format("{}\n", "global-scope-reflect-expression");
+  out_ << "global-scope-reflect-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
 }
 
 void ASTPrinter::visit(NamespaceReflectExpressionAST* ast) {
-  out_ << std::format("{}\n", "namespace-reflect-expression");
+  out_ << "namespace-reflect-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->identifier, "identifier");
 }
 
 void ASTPrinter::visit(TypeIdReflectExpressionAST* ast) {
-  out_ << std::format("{}\n", "type-id-reflect-expression");
+  out_ << "type-id-reflect-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
 }
 
 void ASTPrinter::visit(ReflectExpressionAST* ast) {
-  out_ << std::format("{}\n", "reflect-expression");
+  out_ << "reflect-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(UnaryExpressionAST* ast) {
-  out_ << std::format("{}\n", "unary-expression");
+  out_ << "unary-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->op != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1082,42 +1262,82 @@ void ASTPrinter::visit(UnaryExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(AwaitExpressionAST* ast) {
-  out_ << std::format("{}\n", "await-expression");
+  out_ << "await-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(SizeofExpressionAST* ast) {
-  out_ << std::format("{}\n", "sizeof-expression");
+  out_ << "sizeof-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(SizeofTypeExpressionAST* ast) {
-  out_ << std::format("{}\n", "sizeof-type-expression");
+  out_ << "sizeof-type-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
 }
 
 void ASTPrinter::visit(SizeofPackExpressionAST* ast) {
-  out_ << std::format("{}\n", "sizeof-pack-expression");
+  out_ << "sizeof-pack-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->identifier, "identifier");
 }
 
 void ASTPrinter::visit(AlignofTypeExpressionAST* ast) {
-  out_ << std::format("{}\n", "alignof-type-expression");
+  out_ << "alignof-type-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
 }
 
 void ASTPrinter::visit(AlignofExpressionAST* ast) {
-  out_ << std::format("{}\n", "alignof-expression");
+  out_ << "alignof-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(NoexceptExpressionAST* ast) {
-  out_ << std::format("{}\n", "noexcept-expression");
+  out_ << "noexcept-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(NewExpressionAST* ast) {
-  out_ << std::format("{}\n", "new-expression");
+  out_ << "new-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->newPlacement, "new-placement");
   if (ast->typeSpecifierList) {
     ++indent_;
@@ -1133,18 +1353,33 @@ void ASTPrinter::visit(NewExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(DeleteExpressionAST* ast) {
-  out_ << std::format("{}\n", "delete-expression");
+  out_ << "delete-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(CastExpressionAST* ast) {
-  out_ << std::format("{}\n", "cast-expression");
+  out_ << "cast-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->typeId, "type-id");
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(ImplicitCastExpressionAST* ast) {
-  out_ << std::format("{}\n", "implicit-cast-expression");
+  out_ << "implicit-cast-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   ++indent_;
   out_ << std::format("{:{}}", "", indent_ * 2);
   out_ << std::format("cast-kind: {}\n", to_string(ast->castKind));
@@ -1153,7 +1388,12 @@ void ASTPrinter::visit(ImplicitCastExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(BinaryExpressionAST* ast) {
-  out_ << std::format("{}\n", "binary-expression");
+  out_ << "binary-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->op != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1165,24 +1405,44 @@ void ASTPrinter::visit(BinaryExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(ConditionalExpressionAST* ast) {
-  out_ << std::format("{}\n", "conditional-expression");
+  out_ << "conditional-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->condition, "condition");
   accept(ast->iftrueExpression, "iftrue-expression");
   accept(ast->iffalseExpression, "iffalse-expression");
 }
 
 void ASTPrinter::visit(YieldExpressionAST* ast) {
-  out_ << std::format("{}\n", "yield-expression");
+  out_ << "yield-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(ThrowExpressionAST* ast) {
-  out_ << std::format("{}\n", "throw-expression");
+  out_ << "throw-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(AssignmentExpressionAST* ast) {
-  out_ << std::format("{}\n", "assignment-expression");
+  out_ << "assignment-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->op != TokenKind::T_EOF_SYMBOL) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1194,18 +1454,33 @@ void ASTPrinter::visit(AssignmentExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(PackExpansionExpressionAST* ast) {
-  out_ << std::format("{}\n", "pack-expansion-expression");
+  out_ << "pack-expansion-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(DesignatedInitializerClauseAST* ast) {
-  out_ << std::format("{}\n", "designated-initializer-clause");
+  out_ << "designated-initializer-clause";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->identifier, "identifier");
   accept(ast->initializer, "initializer");
 }
 
 void ASTPrinter::visit(TypeTraitExpressionAST* ast) {
-  out_ << std::format("{}\n", "type-trait-expression");
+  out_ << "type-trait-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->typeIdList) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1218,7 +1493,12 @@ void ASTPrinter::visit(TypeTraitExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(ConditionExpressionAST* ast) {
-  out_ << std::format("{}\n", "condition-expression");
+  out_ << "condition-expression";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->attributeList) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1242,12 +1522,22 @@ void ASTPrinter::visit(ConditionExpressionAST* ast) {
 }
 
 void ASTPrinter::visit(EqualInitializerAST* ast) {
-  out_ << std::format("{}\n", "equal-initializer");
+  out_ << "equal-initializer";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   accept(ast->expression, "expression");
 }
 
 void ASTPrinter::visit(BracedInitListAST* ast) {
-  out_ << std::format("{}\n", "braced-init-list");
+  out_ << "braced-init-list";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->expressionList) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
@@ -1260,7 +1550,12 @@ void ASTPrinter::visit(BracedInitListAST* ast) {
 }
 
 void ASTPrinter::visit(ParenInitializerAST* ast) {
-  out_ << std::format("{}\n", "paren-initializer");
+  out_ << "paren-initializer";
+  if (ast->type) {
+    out_ << std::format(" [{} {}]", to_string(ast->valueCategory),
+                        to_string(ast->type));
+  }
+  out_ << "\n";
   if (ast->expressionList) {
     ++indent_;
     out_ << std::format("{:{}}", "", indent_ * 2);
diff --git a/src/parser/cxx/parser.cc b/src/parser/cxx/parser.cc
index 06d0010a..b54f27a2 100644
--- a/src/parser/cxx/parser.cc
+++ b/src/parser/cxx/parser.cc
@@ -3140,7 +3140,7 @@ auto Parser::parse_unop_expression(ExpressionAST*& yyast,
     case TokenKind::T_STAR: {
       auto pointerType = type_cast<PointerType>(expression->type);
       if (pointerType) {
-        ensure_prvalue(ast->expression);
+        (void)ensure_prvalue(ast->expression);
         ast->type = pointerType->elementType();
         ast->valueCategory = ValueCategory::kLValue;
       }
@@ -3196,7 +3196,7 @@ auto Parser::parse_unop_expression(ExpressionAST*& yyast,
 
     case TokenKind::T_PLUS: {
       ExpressionAST* expr = ast->expression;
-      ensure_prvalue(expr);
+      (void)ensure_prvalue(expr);
       auto ty = control_->remove_cvref(expr->type);
       if (control_->is_arithmetic_or_unscoped_enum(ty) ||
           control_->is_pointer(ty)) {
@@ -3212,7 +3212,7 @@ auto Parser::parse_unop_expression(ExpressionAST*& yyast,
 
     case TokenKind::T_MINUS: {
       ExpressionAST* expr = ast->expression;
-      ensure_prvalue(expr);
+      (void)ensure_prvalue(expr);
       auto ty = control_->remove_cvref(expr->type);
       if (control_->is_arithmetic_or_unscoped_enum(ty)) {
         if (control_->is_integral_or_unscoped_enum(ty)) {
@@ -3234,7 +3234,7 @@ auto Parser::parse_unop_expression(ExpressionAST*& yyast,
 
     case TokenKind::T_TILDE: {
       ExpressionAST* expr = ast->expression;
-      ensure_prvalue(expr);
+      (void)ensure_prvalue(expr);
       auto ty = control_->remove_cvref(expr->type);
       if (control_->is_integral_or_unscoped_enum(ty)) {
         (void)integral_promotion(expr);
@@ -6786,21 +6786,23 @@ auto Parser::qualification_conversion(ExpressionAST*& expr,
   return false;
 }
 
-void Parser::ensure_prvalue(ExpressionAST*& expr) {
+auto Parser::ensure_prvalue(ExpressionAST*& expr) -> bool {
   if (lvalue_to_rvalue_conversion(expr)) {
     expr->valueCategory = ValueCategory::kPrValue;
-    return;
+    return true;
   }
 
   if (array_to_pointer_conversion(expr)) {
     expr->valueCategory = ValueCategory::kPrValue;
-    return;
+    return true;
   }
 
   if (function_to_pointer_conversion(expr)) {
     expr->valueCategory = ValueCategory::kPrValue;
-    return;
+    return true;
   }
+
+  return false;
 }
 
 auto Parser::implicit_conversion(ExpressionAST*& expr,
@@ -6810,6 +6812,7 @@ auto Parser::implicit_conversion(ExpressionAST*& expr,
 
   if (control_->is_same(expr->type, destinationType)) return true;
 
+  auto savedValueCategory = expr->valueCategory;
   auto savedExpr = expr;
   auto didConvert = false;
 
@@ -6839,6 +6842,7 @@ auto Parser::implicit_conversion(ExpressionAST*& expr,
   if (didConvert) return true;
 
   expr = savedExpr;
+  expr->valueCategory = savedValueCategory;
 
   return false;
 }
diff --git a/src/parser/cxx/parser.h b/src/parser/cxx/parser.h
index 12295461..db50d9a1 100644
--- a/src/parser/cxx/parser.h
+++ b/src/parser/cxx/parser.h
@@ -873,7 +873,7 @@ class Parser final {
                                               const Type* destinationType)
       -> bool;
 
-  void ensure_prvalue(ExpressionAST*& expr);
+  [[nodiscard]] auto ensure_prvalue(ExpressionAST*& expr) -> bool;
 
   [[nodiscard]] auto implicit_conversion(ExpressionAST*& expr,
                                          const Type* destinationType) -> bool;
diff --git a/tests/unit_tests/ast/array_to_pointer_conv_01.cc b/tests/unit_tests/ast/array_to_pointer_conv_01.cc
index aaea463b..38fd6e2c 100644
--- a/tests/unit_tests/ast/array_to_pointer_conv_01.cc
+++ b/tests/unit_tests/ast/array_to_pointer_conv_01.cc
@@ -39,7 +39,7 @@ auto main() -> int {
 // CHECK-NEXT:                          identifier: a
 // CHECK-NEXT:                      declarator-chunk-list
 // CHECK-NEXT:                        array-declarator-chunk
-// CHECK-NEXT:                          expression: int-literal-expression
+// CHECK-NEXT:                          expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                            literal: 10
 // CHECK-NEXT:            declaration-statement
 // CHECK-NEXT:              declaration: simple-declaration
@@ -55,13 +55,13 @@ auto main() -> int {
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: p
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue int*]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue int*]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: p
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue int*]
 // CHECK-NEXT:                  cast-kind: array-to-pointer-conversion
-// CHECK-NEXT:                  expression: id-expression
+// CHECK-NEXT:                  expression: id-expression [lvalue int [10]]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: a
diff --git a/tests/unit_tests/ast/asm_declaration_01.cc b/tests/unit_tests/ast/asm_declaration_01.cc
index 4aa1afda..8cd67169 100644
--- a/tests/unit_tests/ast/asm_declaration_01.cc
+++ b/tests/unit_tests/ast/asm_declaration_01.cc
@@ -90,8 +90,8 @@ end:;
 // CHECK-NEXT:                      core-declarator: id-declarator
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: p
-// CHECK-NEXT:                    initializer: equal-initializer
-// CHECK-NEXT:                      expression: nullptr-literal-expression
+// CHECK-NEXT:                    initializer: equal-initializer [prvalue decltype(nullptr)]
+// CHECK-NEXT:                      expression: nullptr-literal-expression [prvalue decltype(nullptr)]
 // CHECK-NEXT:                        literal: nullptr
 // CHECK-NEXT:            declaration-statement
 // CHECK-NEXT:              declaration: asm-declaration
@@ -99,16 +99,16 @@ end:;
 // CHECK-NEXT:                output-operand-list
 // CHECK-NEXT:                  asm-operand
 // CHECK-NEXT:                    constraint-literal: "=r"
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue int]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: a
 // CHECK-NEXT:                  asm-operand
 // CHECK-NEXT:                    constraint-literal: "+rm"
-// CHECK-NEXT:                    expression: unary-expression
+// CHECK-NEXT:                    expression: unary-expression [lvalue char]
 // CHECK-NEXT:                      op: *
-// CHECK-NEXT:                      expression: implicit-cast-expression
+// CHECK-NEXT:                      expression: implicit-cast-expression [prvalue char*]
 // CHECK-NEXT:                        cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                        expression: id-expression
+// CHECK-NEXT:                        expression: id-expression [lvalue char*]
 // CHECK-NEXT:                          unqualified-id: name-id
 // CHECK-NEXT:                            identifier: p
 // CHECK-NEXT:    function-definition
diff --git a/tests/unit_tests/ast/binary_expression_01.cc b/tests/unit_tests/ast/binary_expression_01.cc
index 1bcf301e..7c7f343f 100644
--- a/tests/unit_tests/ast/binary_expression_01.cc
+++ b/tests/unit_tests/ast/binary_expression_01.cc
@@ -18,8 +18,8 @@ int c = a + b * c;
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: a
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: int-literal-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:            expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:              literal: 10
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -31,8 +31,8 @@ int c = a + b * c;
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: b
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: int-literal-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:            expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:              literal: 20
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -44,8 +44,8 @@ int c = a + b * c;
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: c
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: int-literal-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:            expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:              literal: 30
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -57,23 +57,23 @@ int c = a + b * c;
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: c
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: binary-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:            expression: binary-expression [prvalue int]
 // CHECK-NEXT:              op: +
-// CHECK-NEXT:              left-expression: implicit-cast-expression
+// CHECK-NEXT:              left-expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                expression: id-expression
+// CHECK-NEXT:                expression: id-expression [lvalue int]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: a
-// CHECK-NEXT:              right-expression: binary-expression
+// CHECK-NEXT:              right-expression: binary-expression [prvalue int]
 // CHECK-NEXT:                op: *
-// CHECK-NEXT:                left-expression: implicit-cast-expression
+// CHECK-NEXT:                left-expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                  cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                  expression: id-expression
+// CHECK-NEXT:                  expression: id-expression [lvalue int]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: b
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                  cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                  expression: id-expression
+// CHECK-NEXT:                  expression: id-expression [lvalue int]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: c
diff --git a/tests/unit_tests/ast/bitfield_declaration_01.cc b/tests/unit_tests/ast/bitfield_declaration_01.cc
index 2b452f5f..6c566c45 100644
--- a/tests/unit_tests/ast/bitfield_declaration_01.cc
+++ b/tests/unit_tests/ast/bitfield_declaration_01.cc
@@ -24,5 +24,5 @@ struct Bits {
 // CHECK-NEXT:                    core-declarator: bitfield-declarator
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: value
-// CHECK-NEXT:                      size-expression: int-literal-expression
+// CHECK-NEXT:                      size-expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                        literal: 32
diff --git a/tests/unit_tests/ast/bool_literals_01.cc b/tests/unit_tests/ast/bool_literals_01.cc
index 4ddd1043..36b657fa 100644
--- a/tests/unit_tests/ast/bool_literals_01.cc
+++ b/tests/unit_tests/ast/bool_literals_01.cc
@@ -17,8 +17,8 @@ const bool ko = false;
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: ok
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: bool-literal-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue bool]
+// CHECK-NEXT:            expression: bool-literal-expression [prvalue bool]
 // CHECK-NEXT:              is-true: true
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -31,5 +31,5 @@ const bool ko = false;
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: ko
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: bool-literal-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue bool]
+// CHECK-NEXT:            expression: bool-literal-expression [prvalue bool]
diff --git a/tests/unit_tests/ast/boolean_conv_01.cc b/tests/unit_tests/ast/boolean_conv_01.cc
index 3058a1e7..b006bb82 100644
--- a/tests/unit_tests/ast/boolean_conv_01.cc
+++ b/tests/unit_tests/ast/boolean_conv_01.cc
@@ -50,15 +50,15 @@ auto main() -> int {
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: b
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue bool]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue bool]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: b
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue bool]
 // CHECK-NEXT:                  cast-kind: boolean-conversion
-// CHECK-NEXT:                  expression: implicit-cast-expression
+// CHECK-NEXT:                  expression: implicit-cast-expression [prvalue void*]
 // CHECK-NEXT:                    cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue void*]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: ptr
diff --git a/tests/unit_tests/ast/constrained_template_parameter_01.cc b/tests/unit_tests/ast/constrained_template_parameter_01.cc
index 56b94edd..20d5fafd 100644
--- a/tests/unit_tests/ast/constrained_template_parameter_01.cc
+++ b/tests/unit_tests/ast/constrained_template_parameter_01.cc
@@ -21,7 +21,7 @@ constexpr auto ident_v = ident<x>::value;
 // CHECK-NEXT:          identifier: T
 // CHECK-NEXT:      declaration: concept-definition
 // CHECK-NEXT:        identifier: Any
-// CHECK-NEXT:        expression: bool-literal-expression
+// CHECK-NEXT:        expression: bool-literal-expression [prvalue bool]
 // CHECK-NEXT:          is-true: true
 // CHECK-NEXT:    template-declaration
 // CHECK-NEXT:      template-parameter-list
diff --git a/tests/unit_tests/ast/deduce_this_01.cc b/tests/unit_tests/ast/deduce_this_01.cc
index 84913cd4..ce44028c 100644
--- a/tests/unit_tests/ast/deduce_this_01.cc
+++ b/tests/unit_tests/ast/deduce_this_01.cc
@@ -18,7 +18,7 @@ struct object {
 // CHECK-NEXT:          identifier: T
 // CHECK-NEXT:      declaration: concept-definition
 // CHECK-NEXT:        identifier: ok
-// CHECK-NEXT:        expression: bool-literal-expression
+// CHECK-NEXT:        expression: bool-literal-expression [prvalue bool]
 // CHECK-NEXT:          is-true: true
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -51,6 +51,6 @@ struct object {
 // CHECK-NEXT:                statement: compound-statement
 // CHECK-NEXT:                  statement-list
 // CHECK-NEXT:                    return-statement
-// CHECK-NEXT:                      expression: id-expression
+// CHECK-NEXT:                      expression: id-expression [lvalue auto]
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: self
diff --git a/tests/unit_tests/ast/designated_initializer_01.cc b/tests/unit_tests/ast/designated_initializer_01.cc
index b96464ee..74933980 100644
--- a/tests/unit_tests/ast/designated_initializer_01.cc
+++ b/tests/unit_tests/ast/designated_initializer_01.cc
@@ -58,11 +58,11 @@ auto pair = Pair{
 // CHECK-NEXT:                expression-list
 // CHECK-NEXT:                  designated-initializer-clause
 // CHECK-NEXT:                    identifier: first
-// CHECK-NEXT:                    initializer: equal-initializer
-// CHECK-NEXT:                      expression: int-literal-expression
+// CHECK-NEXT:                    initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:                      expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                        literal: 1
 // CHECK-NEXT:                  designated-initializer-clause
 // CHECK-NEXT:                    identifier: second
-// CHECK-NEXT:                    initializer: equal-initializer
-// CHECK-NEXT:                      expression: int-literal-expression
+// CHECK-NEXT:                    initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:                      expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                        literal: 2
diff --git a/tests/unit_tests/ast/enum_definition_01.cc b/tests/unit_tests/ast/enum_definition_01.cc
index f1bc7412..10d43cc6 100644
--- a/tests/unit_tests/ast/enum_definition_01.cc
+++ b/tests/unit_tests/ast/enum_definition_01.cc
@@ -41,15 +41,15 @@ enum class Kind3 : int {
 // CHECK-NEXT:          enumerator-list
 // CHECK-NEXT:            enumerator
 // CHECK-NEXT:              identifier: k1
-// CHECK-NEXT:              expression: int-literal-expression
+// CHECK-NEXT:              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                literal: 0
 // CHECK-NEXT:            enumerator
 // CHECK-NEXT:              identifier: k2
-// CHECK-NEXT:              expression: int-literal-expression
+// CHECK-NEXT:              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                literal: 1
 // CHECK-NEXT:            enumerator
 // CHECK-NEXT:              identifier: k3
-// CHECK-NEXT:              expression: int-literal-expression
+// CHECK-NEXT:              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                literal: 2
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -62,13 +62,13 @@ enum class Kind3 : int {
 // CHECK-NEXT:          enumerator-list
 // CHECK-NEXT:            enumerator
 // CHECK-NEXT:              identifier: k1
-// CHECK-NEXT:              expression: int-literal-expression
+// CHECK-NEXT:              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                literal: 0
 // CHECK-NEXT:            enumerator
 // CHECK-NEXT:              identifier: k2
-// CHECK-NEXT:              expression: int-literal-expression
+// CHECK-NEXT:              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                literal: 1
 // CHECK-NEXT:            enumerator
 // CHECK-NEXT:              identifier: k3
-// CHECK-NEXT:              expression: int-literal-expression
+// CHECK-NEXT:              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                literal: 2
diff --git a/tests/unit_tests/ast/equal_initializer_01.cc b/tests/unit_tests/ast/equal_initializer_01.cc
index 870966ba..ba3618fb 100644
--- a/tests/unit_tests/ast/equal_initializer_01.cc
+++ b/tests/unit_tests/ast/equal_initializer_01.cc
@@ -25,9 +25,9 @@ const int values[] = {
 // CHECK-NEXT:          initializer: equal-initializer
 // CHECK-NEXT:            expression: braced-init-list
 // CHECK-NEXT:              expression-list
-// CHECK-NEXT:                int-literal-expression
+// CHECK-NEXT:                int-literal-expression [prvalue int]
 // CHECK-NEXT:                  literal: 1
-// CHECK-NEXT:                int-literal-expression
+// CHECK-NEXT:                int-literal-expression [prvalue int]
 // CHECK-NEXT:                  literal: 2
-// CHECK-NEXT:                int-literal-expression
+// CHECK-NEXT:                int-literal-expression [prvalue int]
 // CHECK-NEXT:                  literal: 3
diff --git a/tests/unit_tests/ast/floating_integral_conv_01.cc b/tests/unit_tests/ast/floating_integral_conv_01.cc
index af68930a..bc2dad33 100644
--- a/tests/unit_tests/ast/floating_integral_conv_01.cc
+++ b/tests/unit_tests/ast/floating_integral_conv_01.cc
@@ -82,15 +82,15 @@ auto main() -> int {
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: i
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue double]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue double]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: d
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue double]
 // CHECK-NEXT:                  cast-kind: floating-integral-conversion
-// CHECK-NEXT:                  expression: implicit-cast-expression
+// CHECK-NEXT:                  expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                    cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue int]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: i
diff --git a/tests/unit_tests/ast/floating_point_conv_01.cc b/tests/unit_tests/ast/floating_point_conv_01.cc
index 6585017a..d4cdcf27 100644
--- a/tests/unit_tests/ast/floating_point_conv_01.cc
+++ b/tests/unit_tests/ast/floating_point_conv_01.cc
@@ -82,15 +82,15 @@ auto main() -> int {
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: d
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue float]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue float]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: f
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue float]
 // CHECK-NEXT:                  cast-kind: floating-point-conversion
-// CHECK-NEXT:                  expression: implicit-cast-expression
+// CHECK-NEXT:                  expression: implicit-cast-expression [prvalue double]
 // CHECK-NEXT:                    cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue double]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: d
diff --git a/tests/unit_tests/ast/floating_point_promotion_01.cc b/tests/unit_tests/ast/floating_point_promotion_01.cc
index 6fc9d56b..51b80881 100644
--- a/tests/unit_tests/ast/floating_point_promotion_01.cc
+++ b/tests/unit_tests/ast/floating_point_promotion_01.cc
@@ -82,15 +82,15 @@ auto main() -> int {
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: d
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue double]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue double]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: d
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue double]
 // CHECK-NEXT:                  cast-kind: floating-point-promotion
-// CHECK-NEXT:                  expression: implicit-cast-expression
+// CHECK-NEXT:                  expression: implicit-cast-expression [prvalue float]
 // CHECK-NEXT:                    cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue float]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: f
diff --git a/tests/unit_tests/ast/for_range_statement_01.cc b/tests/unit_tests/ast/for_range_statement_01.cc
index c6e446eb..db4ee2b1 100644
--- a/tests/unit_tests/ast/for_range_statement_01.cc
+++ b/tests/unit_tests/ast/for_range_statement_01.cc
@@ -34,10 +34,10 @@ int main() {
 // CHECK-NEXT:                          identifier: i
 // CHECK-NEXT:              range-initializer: braced-init-list
 // CHECK-NEXT:                expression-list
-// CHECK-NEXT:                  int-literal-expression
+// CHECK-NEXT:                  int-literal-expression [prvalue int]
 // CHECK-NEXT:                    literal: 10
-// CHECK-NEXT:                  int-literal-expression
+// CHECK-NEXT:                  int-literal-expression [prvalue int]
 // CHECK-NEXT:                    literal: 20
-// CHECK-NEXT:                  int-literal-expression
+// CHECK-NEXT:                  int-literal-expression [prvalue int]
 // CHECK-NEXT:                    literal: 30
 // CHECK-NEXT:              statement: compound-statement
diff --git a/tests/unit_tests/ast/for_range_statement_02.cc b/tests/unit_tests/ast/for_range_statement_02.cc
index 5937a749..9cd48421 100644
--- a/tests/unit_tests/ast/for_range_statement_02.cc
+++ b/tests/unit_tests/ast/for_range_statement_02.cc
@@ -36,16 +36,16 @@ int main() {
 // CHECK-NEXT:                      declarator-chunk-list
 // CHECK-NEXT:                        array-declarator-chunk
 // CHECK-NEXT:                        array-declarator-chunk
-// CHECK-NEXT:                          expression: int-literal-expression
+// CHECK-NEXT:                          expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                            literal: 2
 // CHECK-NEXT:                    initializer: equal-initializer
 // CHECK-NEXT:                      expression: braced-init-list
 // CHECK-NEXT:                        expression-list
 // CHECK-NEXT:                          braced-init-list
 // CHECK-NEXT:                            expression-list
-// CHECK-NEXT:                              int-literal-expression
+// CHECK-NEXT:                              int-literal-expression [prvalue int]
 // CHECK-NEXT:                                literal: 1
-// CHECK-NEXT:                              int-literal-expression
+// CHECK-NEXT:                              int-literal-expression [prvalue int]
 // CHECK-NEXT:                                literal: 2
 // CHECK-NEXT:            for-range-statement
 // CHECK-NEXT:              range-declaration: structured-binding-declaration
@@ -57,7 +57,7 @@ int main() {
 // CHECK-NEXT:                    identifier: key
 // CHECK-NEXT:                  name-id
 // CHECK-NEXT:                    identifier: value
-// CHECK-NEXT:              range-initializer: id-expression
+// CHECK-NEXT:              range-initializer: id-expression [lvalue int [][2]]
 // CHECK-NEXT:                unqualified-id: name-id
 // CHECK-NEXT:                  identifier: map
 // CHECK-NEXT:              statement: compound-statement
diff --git a/tests/unit_tests/ast/function_to_pointer_conv_01.cc b/tests/unit_tests/ast/function_to_pointer_conv_01.cc
index 8ae1a8c6..5b8ac4cc 100644
--- a/tests/unit_tests/ast/function_to_pointer_conv_01.cc
+++ b/tests/unit_tests/ast/function_to_pointer_conv_01.cc
@@ -85,15 +85,15 @@ auto main() -> int {
 // CHECK-NEXT:                                  integral-type-specifier
 // CHECK-NEXT:                                    specifier: int
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue void (*)(int, int)]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue void (*)(int, int)]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: p
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue void (*)(int, int)]
 // CHECK-NEXT:                  cast-kind: function-pointer-conversion
-// CHECK-NEXT:                  expression: implicit-cast-expression
+// CHECK-NEXT:                  expression: implicit-cast-expression [prvalue void (*)(int, int)]
 // CHECK-NEXT:                    cast-kind: function-to-pointer-conversion
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue void (int, int)]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: f
diff --git a/tests/unit_tests/ast/if_statement_01.cc b/tests/unit_tests/ast/if_statement_01.cc
index 89d57162..27399583 100644
--- a/tests/unit_tests/ast/if_statement_01.cc
+++ b/tests/unit_tests/ast/if_statement_01.cc
@@ -27,4 +27,4 @@ auto main() -> int {
 // CHECK-NEXT:        statement: compound-statement
 // CHECK-NEXT:          statement-list
 // CHECK-NEXT:            if-statement
-// CHECK-NEXT:              condition: bool-literal-expression
+// CHECK-NEXT:              condition: bool-literal-expression [prvalue bool]
diff --git a/tests/unit_tests/ast/integral_conversion_01.cc b/tests/unit_tests/ast/integral_conversion_01.cc
index 8793a6cc..81d52717 100644
--- a/tests/unit_tests/ast/integral_conversion_01.cc
+++ b/tests/unit_tests/ast/integral_conversion_01.cc
@@ -82,15 +82,15 @@ auto main() -> int {
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: i
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue char]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue char]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: c
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue char]
 // CHECK-NEXT:                  cast-kind: integral-conversion
-// CHECK-NEXT:                  expression: implicit-cast-expression
+// CHECK-NEXT:                  expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                    cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue int]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: i
diff --git a/tests/unit_tests/ast/integral_promotion_conv_01.cc b/tests/unit_tests/ast/integral_promotion_conv_01.cc
index 417f8e6d..37bf467b 100644
--- a/tests/unit_tests/ast/integral_promotion_conv_01.cc
+++ b/tests/unit_tests/ast/integral_promotion_conv_01.cc
@@ -82,15 +82,15 @@ auto main() -> int {
 // CHECK-NEXT:                        unqualified-id: name-id
 // CHECK-NEXT:                          identifier: i
 // CHECK-NEXT:            expression-statement
-// CHECK-NEXT:              expression: assignment-expression
+// CHECK-NEXT:              expression: assignment-expression [prvalue int]
 // CHECK-NEXT:                op: =
-// CHECK-NEXT:                left-expression: id-expression
+// CHECK-NEXT:                left-expression: id-expression [lvalue int]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: i
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                  cast-kind: integral-promotion
-// CHECK-NEXT:                  expression: implicit-cast-expression
+// CHECK-NEXT:                  expression: implicit-cast-expression [prvalue char]
 // CHECK-NEXT:                    cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue char]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: c
diff --git a/tests/unit_tests/ast/lambda_specifier_01.cc b/tests/unit_tests/ast/lambda_specifier_01.cc
index 71a165c9..ed300ea8 100644
--- a/tests/unit_tests/ast/lambda_specifier_01.cc
+++ b/tests/unit_tests/ast/lambda_specifier_01.cc
@@ -45,7 +45,7 @@ auto main() -> int {
 // CHECK-NEXT:                        statement: compound-statement
 // CHECK-NEXT:                          statement-list
 // CHECK-NEXT:                            return-statement
-// CHECK-NEXT:                              expression: int-literal-expression
+// CHECK-NEXT:                              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                                literal: 0
 // CHECK-NEXT:            declaration-statement
 // CHECK-NEXT:              declaration: simple-declaration
@@ -65,7 +65,7 @@ auto main() -> int {
 // CHECK-NEXT:                        statement: compound-statement
 // CHECK-NEXT:                          statement-list
 // CHECK-NEXT:                            return-statement
-// CHECK-NEXT:                              expression: int-literal-expression
+// CHECK-NEXT:                              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                                literal: 0
 // CHECK-NEXT:            declaration-statement
 // CHECK-NEXT:              declaration: simple-declaration
@@ -85,7 +85,7 @@ auto main() -> int {
 // CHECK-NEXT:                        statement: compound-statement
 // CHECK-NEXT:                          statement-list
 // CHECK-NEXT:                            return-statement
-// CHECK-NEXT:                              expression: int-literal-expression
+// CHECK-NEXT:                              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                                literal: 0
 // CHECK-NEXT:            declaration-statement
 // CHECK-NEXT:              declaration: simple-declaration
@@ -105,6 +105,6 @@ auto main() -> int {
 // CHECK-NEXT:                        statement: compound-statement
 // CHECK-NEXT:                          statement-list
 // CHECK-NEXT:                            return-statement
-// CHECK-NEXT:                              expression: int-literal-expression
+// CHECK-NEXT:                              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                                literal: 0
 // CHECK-NEXT:    empty-declaration
diff --git a/tests/unit_tests/ast/new_expression_01.cc b/tests/unit_tests/ast/new_expression_01.cc
index 2a85c5c2..67468d22 100644
--- a/tests/unit_tests/ast/new_expression_01.cc
+++ b/tests/unit_tests/ast/new_expression_01.cc
@@ -63,7 +63,7 @@ auto make(void* where, T init) {
 // CHECK-NEXT:                        expression: new-expression
 // CHECK-NEXT:                          new-placement: new-placement
 // CHECK-NEXT:                            expression-list
-// CHECK-NEXT:                              id-expression
+// CHECK-NEXT:                              id-expression [lvalue void*]
 // CHECK-NEXT:                                unqualified-id: name-id
 // CHECK-NEXT:                                  identifier: where
 // CHECK-NEXT:                          type-specifier-list
@@ -73,7 +73,7 @@ auto make(void* where, T init) {
 // CHECK-NEXT:                          new-initalizer: new-braced-initializer
 // CHECK-NEXT:                            braced-init-list: braced-init-list
 // CHECK-NEXT:                              expression-list
-// CHECK-NEXT:                                id-expression
+// CHECK-NEXT:                                id-expression [lvalue T]
 // CHECK-NEXT:                                  unqualified-id: name-id
 // CHECK-NEXT:                                    identifier: init
 // CHECK-NEXT:              declaration-statement
@@ -90,7 +90,7 @@ auto make(void* where, T init) {
 // CHECK-NEXT:                        expression: new-expression
 // CHECK-NEXT:                          new-placement: new-placement
 // CHECK-NEXT:                            expression-list
-// CHECK-NEXT:                              id-expression
+// CHECK-NEXT:                              id-expression [lvalue void*]
 // CHECK-NEXT:                                unqualified-id: name-id
 // CHECK-NEXT:                                  identifier: where
 // CHECK-NEXT:                          type-specifier-list
@@ -99,6 +99,6 @@ auto make(void* where, T init) {
 // CHECK-NEXT:                                identifier: T
 // CHECK-NEXT:                          new-initalizer: new-paren-initializer
 // CHECK-NEXT:                            expression-list
-// CHECK-NEXT:                              id-expression
+// CHECK-NEXT:                              id-expression [lvalue T]
 // CHECK-NEXT:                                unqualified-id: name-id
 // CHECK-NEXT:                                  identifier: init
diff --git a/tests/unit_tests/ast/pack_expansion_01.cc b/tests/unit_tests/ast/pack_expansion_01.cc
index 9a7d20bf..43c9f24e 100644
--- a/tests/unit_tests/ast/pack_expansion_01.cc
+++ b/tests/unit_tests/ast/pack_expansion_01.cc
@@ -53,11 +53,11 @@ void foo(int x, auto... xs) { foo(xs...); }
 // CHECK-NEXT:          statement-list
 // CHECK-NEXT:            expression-statement
 // CHECK-NEXT:              expression: call-expression
-// CHECK-NEXT:                base-expression: id-expression
+// CHECK-NEXT:                base-expression: id-expression [lvalue $overload-set]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: foo
 // CHECK-NEXT:                expression-list
 // CHECK-NEXT:                  pack-expansion-expression
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue auto]
 // CHECK-NEXT:                      unqualified-id: name-id
 // CHECK-NEXT:                        identifier: xs
diff --git a/tests/unit_tests/ast/reflect_01.cc b/tests/unit_tests/ast/reflect_01.cc
index 8971e7e9..57f8f206 100644
--- a/tests/unit_tests/ast/reflect_01.cc
+++ b/tests/unit_tests/ast/reflect_01.cc
@@ -54,7 +54,7 @@ constexpr auto x = [:z:];
 // CHECK-NEXT:        constexpr-specifier
 // CHECK-NEXT:        splicer-type-specifier
 // CHECK-NEXT:          splicer: splicer
-// CHECK-NEXT:            expression: id-expression
+// CHECK-NEXT:            expression: id-expression [lvalue auto]
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: int_ty
 // CHECK-NEXT:      init-declarator-list
@@ -63,15 +63,15 @@ constexpr auto x = [:z:];
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: i
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: int-literal-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:            expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:              literal: 0
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
 // CHECK-NEXT:        constexpr-specifier
 // CHECK-NEXT:        splicer-type-specifier
 // CHECK-NEXT:          splicer: splicer
-// CHECK-NEXT:            expression: id-expression
+// CHECK-NEXT:            expression: id-expression [lvalue auto]
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: ptr_ty
 // CHECK-NEXT:      init-declarator-list
@@ -80,8 +80,8 @@ constexpr auto x = [:z:];
 // CHECK-NEXT:            core-declarator: id-declarator
 // CHECK-NEXT:              unqualified-id: name-id
 // CHECK-NEXT:                identifier: ptr
-// CHECK-NEXT:          initializer: equal-initializer
-// CHECK-NEXT:            expression: nullptr-literal-expression
+// CHECK-NEXT:          initializer: equal-initializer [prvalue decltype(nullptr)]
+// CHECK-NEXT:            expression: nullptr-literal-expression [prvalue decltype(nullptr)]
 // CHECK-NEXT:              literal: nullptr
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -95,7 +95,7 @@ constexpr auto x = [:z:];
 // CHECK-NEXT:                identifier: z
 // CHECK-NEXT:          initializer: equal-initializer
 // CHECK-NEXT:            expression: reflect-expression
-// CHECK-NEXT:              expression: int-literal-expression
+// CHECK-NEXT:              expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                literal: 123
 // CHECK-NEXT:    simple-declaration
 // CHECK-NEXT:      decl-specifier-list
@@ -110,6 +110,6 @@ constexpr auto x = [:z:];
 // CHECK-NEXT:          initializer: equal-initializer
 // CHECK-NEXT:            expression: splice-expression
 // CHECK-NEXT:              splicer: splicer
-// CHECK-NEXT:                expression: id-expression
+// CHECK-NEXT:                expression: id-expression [lvalue auto]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: z
diff --git a/tests/unit_tests/ast/reflect_02.cc b/tests/unit_tests/ast/reflect_02.cc
index ef853448..edd4aece 100644
--- a/tests/unit_tests/ast/reflect_02.cc
+++ b/tests/unit_tests/ast/reflect_02.cc
@@ -56,12 +56,12 @@ auto main() -> int { return S{.x = 10}.[:^S::x:]; }
 // CHECK-NEXT:                    expression-list
 // CHECK-NEXT:                      designated-initializer-clause
 // CHECK-NEXT:                        identifier: x
-// CHECK-NEXT:                        initializer: equal-initializer
-// CHECK-NEXT:                          expression: int-literal-expression
+// CHECK-NEXT:                        initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:                          expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                            literal: 10
 // CHECK-NEXT:                splicer: splicer
 // CHECK-NEXT:                  expression: reflect-expression
-// CHECK-NEXT:                    expression: id-expression
+// CHECK-NEXT:                    expression: id-expression [lvalue int]
 // CHECK-NEXT:                      nested-name-specifier: simple-nested-name-specifier
 // CHECK-NEXT:                        identifier: S
 // CHECK-NEXT:                      unqualified-id: name-id
diff --git a/tests/unit_tests/ast/return_statement_01.cc b/tests/unit_tests/ast/return_statement_01.cc
index ed700180..4032642c 100644
--- a/tests/unit_tests/ast/return_statement_01.cc
+++ b/tests/unit_tests/ast/return_statement_01.cc
@@ -59,7 +59,7 @@ struct Pair {
 // CHECK-NEXT:                    return-statement
 // CHECK-NEXT:                      expression: braced-init-list
 // CHECK-NEXT:                        expression-list
-// CHECK-NEXT:                          int-literal-expression
+// CHECK-NEXT:                          int-literal-expression [prvalue int]
 // CHECK-NEXT:                            literal: 0
-// CHECK-NEXT:                          int-literal-expression
+// CHECK-NEXT:                          int-literal-expression [prvalue int]
 // CHECK-NEXT:                            literal: 0
diff --git a/tests/unit_tests/ast/structured_binding_declaration_01.cc b/tests/unit_tests/ast/structured_binding_declaration_01.cc
index 4ff506f8..017674b1 100644
--- a/tests/unit_tests/ast/structured_binding_declaration_01.cc
+++ b/tests/unit_tests/ast/structured_binding_declaration_01.cc
@@ -66,10 +66,10 @@ struct Pair {
 // CHECK-NEXT:                            identifier: a
 // CHECK-NEXT:                          name-id
 // CHECK-NEXT:                            identifier: b
-// CHECK-NEXT:                        initializer: equal-initializer
-// CHECK-NEXT:                          expression: unary-expression
+// CHECK-NEXT:                        initializer: equal-initializer [lvalue ::Pair]
+// CHECK-NEXT:                          expression: unary-expression [lvalue ::Pair]
 // CHECK-NEXT:                            op: *
-// CHECK-NEXT:                            expression: this-expression
+// CHECK-NEXT:                            expression: this-expression [prvalue ::Pair*]
 // CHECK-NEXT:                    return-statement
 // CHECK-NEXT:                      expression: binary-expression
 // CHECK-NEXT:                        op: +
diff --git a/tests/unit_tests/ast/template_lambda_01.cc b/tests/unit_tests/ast/template_lambda_01.cc
index e3ebeadc..caec7651 100644
--- a/tests/unit_tests/ast/template_lambda_01.cc
+++ b/tests/unit_tests/ast/template_lambda_01.cc
@@ -83,9 +83,9 @@ struct S {
 // CHECK-NEXT:                                      return-statement
 // CHECK-NEXT:                                        expression: binary-expression
 // CHECK-NEXT:                                          op: +
-// CHECK-NEXT:                                          left-expression: id-expression
+// CHECK-NEXT:                                          left-expression: id-expression [lvalue T1]
 // CHECK-NEXT:                                            unqualified-id: name-id
 // CHECK-NEXT:                                              identifier: a
-// CHECK-NEXT:                                          right-expression: id-expression
+// CHECK-NEXT:                                          right-expression: id-expression [lvalue T2]
 // CHECK-NEXT:                                            unqualified-id: name-id
 // CHECK-NEXT:                                              identifier: b
diff --git a/tests/unit_tests/ast/template_member_expression_01.cc b/tests/unit_tests/ast/template_member_expression_01.cc
index b7dfcc90..c0be47ed 100644
--- a/tests/unit_tests/ast/template_member_expression_01.cc
+++ b/tests/unit_tests/ast/template_member_expression_01.cc
@@ -53,7 +53,7 @@ auto copy(Allocator &A) -> void * { return A.template Allocate<char>(128); }
 // CHECK-NEXT:                  statement: compound-statement
 // CHECK-NEXT:                    statement-list
 // CHECK-NEXT:                      return-statement
-// CHECK-NEXT:                        expression: nullptr-literal-expression
+// CHECK-NEXT:                        expression: nullptr-literal-expression [prvalue decltype(nullptr)]
 // CHECK-NEXT:                          literal: nullptr
 // CHECK-NEXT:    function-definition
 // CHECK-NEXT:      decl-specifier-list
@@ -94,7 +94,7 @@ auto copy(Allocator &A) -> void * { return A.template Allocate<char>(128); }
 // CHECK-NEXT:                base-expression: member-expression
 // CHECK-NEXT:                  access-op: .
 // CHECK-NEXT:                  is-template-introduced: true
-// CHECK-NEXT:                  base-expression: id-expression
+// CHECK-NEXT:                  base-expression: id-expression [lvalue ::Allocator]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: A
 // CHECK-NEXT:                  unqualified-id: simple-template-id
@@ -106,5 +106,5 @@ auto copy(Allocator &A) -> void * { return A.template Allocate<char>(128); }
 // CHECK-NEXT:                            integral-type-specifier
 // CHECK-NEXT:                              specifier: char
 // CHECK-NEXT:                expression-list
-// CHECK-NEXT:                  int-literal-expression
+// CHECK-NEXT:                  int-literal-expression [prvalue int]
 // CHECK-NEXT:                    literal: 128
diff --git a/tests/unit_tests/ast/variadic_function_02.cc b/tests/unit_tests/ast/variadic_function_02.cc
index 76ca84d9..7b79a228 100644
--- a/tests/unit_tests/ast/variadic_function_02.cc
+++ b/tests/unit_tests/ast/variadic_function_02.cc
@@ -53,10 +53,10 @@ void ff(int count, ...) {
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: __builtin_va_start
 // CHECK-NEXT:                expression-list
-// CHECK-NEXT:                  id-expression
+// CHECK-NEXT:                  id-expression [lvalue __builtin_va_list]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: args
-// CHECK-NEXT:                  id-expression
+// CHECK-NEXT:                  id-expression [lvalue int]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: count
 // CHECK-NEXT:            for-statement
@@ -71,24 +71,24 @@ void ff(int count, ...) {
 // CHECK-NEXT:                        core-declarator: id-declarator
 // CHECK-NEXT:                          unqualified-id: name-id
 // CHECK-NEXT:                            identifier: i
-// CHECK-NEXT:                      initializer: equal-initializer
-// CHECK-NEXT:                        expression: int-literal-expression
+// CHECK-NEXT:                      initializer: equal-initializer [prvalue int]
+// CHECK-NEXT:                        expression: int-literal-expression [prvalue int]
 // CHECK-NEXT:                          literal: 0
-// CHECK-NEXT:              condition: binary-expression
+// CHECK-NEXT:              condition: binary-expression [prvalue bool]
 // CHECK-NEXT:                op: <
-// CHECK-NEXT:                left-expression: implicit-cast-expression
+// CHECK-NEXT:                left-expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                  cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                  expression: id-expression
+// CHECK-NEXT:                  expression: id-expression [lvalue int]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: i
-// CHECK-NEXT:                right-expression: implicit-cast-expression
+// CHECK-NEXT:                right-expression: implicit-cast-expression [prvalue int]
 // CHECK-NEXT:                  cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                  expression: id-expression
+// CHECK-NEXT:                  expression: id-expression [lvalue int]
 // CHECK-NEXT:                    unqualified-id: name-id
 // CHECK-NEXT:                      identifier: count
-// CHECK-NEXT:              expression: unary-expression
+// CHECK-NEXT:              expression: unary-expression [lvalue int]
 // CHECK-NEXT:                op: ++
-// CHECK-NEXT:                expression: id-expression
+// CHECK-NEXT:                expression: id-expression [lvalue int]
 // CHECK-NEXT:                  unqualified-id: name-id
 // CHECK-NEXT:                    identifier: i
 // CHECK-NEXT:              statement: compound-statement
@@ -99,7 +99,7 @@ void ff(int count, ...) {
 // CHECK-NEXT:                        type-specifier-list
 // CHECK-NEXT:                          void-type-specifier
 // CHECK-NEXT:                      expression: va-arg-expression
-// CHECK-NEXT:                        expression: id-expression
+// CHECK-NEXT:                        expression: id-expression [lvalue __builtin_va_list]
 // CHECK-NEXT:                          unqualified-id: name-id
 // CHECK-NEXT:                            identifier: args
 // CHECK-NEXT:                        type-id: type-id