diff --git a/Sources/Sdf/variableExpressionParser.cpp b/Sources/Sdf/variableExpressionParser.cpp
index 281ca6eba..43f923e7c 100644
--- a/Sources/Sdf/variableExpressionParser.cpp
+++ b/Sources/Sdf/variableExpressionParser.cpp
@@ -22,6 +22,8 @@ PXR_NAMESPACE_OPEN_SCOPE
 
 namespace {
 
+using namespace PXR_PEGTL_NAMESPACE;
+
 namespace Impl = Sdf_VariableExpressionImpl;
 
 // Node creators -----------------------------------------------
@@ -281,13 +283,13 @@ void _ThrowParseError(const Input &in, const std::string &msg)
 // missing "}". This is because it recognizes everything up to the
 // illegal character as the variable and expects to find the
 // closing "}" after it. It'd be nice to fix this.
-struct VariableStart : PXR_PEGTL_NAMESPACE::ascii::string<'$', '{'> {};
+struct VariableStart : string<'$', '{'> {};
 
-struct VariableEnd : PXR_PEGTL_NAMESPACE::ascii::string<'}'> {};
+struct VariableEnd : string<'}'> {};
 
 template<class C> struct VariableName : identifier {};
 
-template<class C> struct VariableImpl : PXR_PEGTL_NAMESPACE::internal::if_must<VariableStart, VariableName<C>, VariableEnd> {
+template<class C> struct VariableImpl : if_must<VariableStart, VariableName<C>, VariableEnd> {
   using Name = VariableName<C>;
 };
 
@@ -304,23 +306,23 @@ template<char QuoteChar> struct QuotedStringEscapedChar : one<'`', '$', '\\', Qu
 
 // Sequence of allowed characters in a quoted string.
 template<char QuoteChar>
-struct QuotedStringChars : PXR_PEGTL_NAMESPACE::internal::plus<PXR_PEGTL_NAMESPACE::internal::sor<
+struct QuotedStringChars : plus<sor<
                                // An escaped character.
-                               PXR_PEGTL_NAMESPACE::internal::seq<one<'\\'>, QuotedStringEscapedChar<QuoteChar>>,
+                               seq<one<'\\'>, QuotedStringEscapedChar<QuoteChar>>,
                                // Any other characters that aren't the start of a stage
                                // variable or the quote character, since those are handled
                                // by different rules.
-                               PXR_PEGTL_NAMESPACE::internal::seq<PXR_PEGTL_NAMESPACE::internal::not_at<PXR_PEGTL_NAMESPACE::internal::sor<VariableStart, one<QuoteChar>>>, any>>> {};
+                               seq<not_at<sor<VariableStart, one<QuoteChar>>>, any>>> {};
 
-template<char QuoteChar> struct QuotedStringStart : PXR_PEGTL_NAMESPACE::ascii::string<QuoteChar> {};
+template<char QuoteChar> struct QuotedStringStart : string<QuoteChar> {};
 
-template<char QuoteChar> struct QuotedStringEnd : PXR_PEGTL_NAMESPACE::ascii::string<QuoteChar> {};
+template<char QuoteChar> struct QuotedStringEnd : string<QuoteChar> {};
 
 template<char QuoteChar>
-struct QuotedStringBody : PXR_PEGTL_NAMESPACE::internal::star<PXR_PEGTL_NAMESPACE::internal::sor<QuotedStringVariable, QuotedStringChars<QuoteChar>>> {};
+struct QuotedStringBody : star<sor<QuotedStringVariable, QuotedStringChars<QuoteChar>>> {};
 
 template<char QuoteChar>
-struct QuotedString : PXR_PEGTL_NAMESPACE::internal::if_must<QuotedStringStart<QuoteChar>,
+struct QuotedString : if_must<QuotedStringStart<QuoteChar>,
                               QuotedStringBody<QuoteChar>,
                               QuotedStringEnd<QuoteChar>> {
   using Start = QuotedStringStart<QuoteChar>;
@@ -333,7 +335,7 @@ using SingleQuotedString = QuotedString<'\''>;
 
 // ----------------------------------------
 
-struct Integer : PXR_PEGTL_NAMESPACE::internal::seq<PXR_PEGTL_NAMESPACE::internal::opt<one<'-'>>, PXR_PEGTL_NAMESPACE::internal::plus<ascii::digit>> {};
+struct Integer : seq<opt<one<'-'>>, plus<ascii::digit>> {};
 
 // ----------------------------------------
 
@@ -341,15 +343,15 @@ struct Integer : PXR_PEGTL_NAMESPACE::internal::seq<PXR_PEGTL_NAMESPACE::interna
 // are the representations used in the two primary languages supported
 // by USD -- C++ and Python -- and that correspondence may make it easier
 // for users working in those languages while writing expressions.
-struct BooleanTrue : PXR_PEGTL_NAMESPACE::internal::sor<PXR_PEGTL_KEYWORD("True"), PXR_PEGTL_KEYWORD("true")> {};
+struct BooleanTrue : sor<PXR_PEGTL_KEYWORD("True"), PXR_PEGTL_KEYWORD("true")> {};
 
-struct BooleanFalse : PXR_PEGTL_NAMESPACE::internal::sor<PXR_PEGTL_KEYWORD("False"), PXR_PEGTL_KEYWORD("false")> {};
+struct BooleanFalse : sor<PXR_PEGTL_KEYWORD("False"), PXR_PEGTL_KEYWORD("false")> {};
 
-struct Boolean : PXR_PEGTL_NAMESPACE::internal::sor<BooleanTrue, BooleanFalse> {};
+struct Boolean : sor<BooleanTrue, BooleanFalse> {};
 
 // ----------------------------------------
 
-struct None : PXR_PEGTL_NAMESPACE::internal::sor<PXR_PEGTL_KEYWORD("None"), PXR_PEGTL_KEYWORD("none")> {};
+struct None : sor<PXR_PEGTL_KEYWORD("None"), PXR_PEGTL_KEYWORD("none")> {};
 
 // ----------------------------------------
 
@@ -358,9 +360,9 @@ struct ExpressionBody;
 
 struct FunctionName : identifier {};
 
-struct FunctionArgumentStart : PXR_PEGTL_NAMESPACE::internal::pad<one<'('>, one<' '>> {};
+struct FunctionArgumentStart : pad<one<'('>, one<' '>> {};
 
-struct FunctionArgumentEnd : PXR_PEGTL_NAMESPACE::internal::pad<one<')'>, one<' '>> {};
+struct FunctionArgumentEnd : pad<one<')'>, one<' '>> {};
 
 // A function argument can be any valid expression. We can't directly
 // derive from ExpressionBody because doing so would require ExpressionBody
@@ -371,15 +373,15 @@ template<class Base> struct FunctionArgumentWrapper : public Base {};
 using FunctionArgument = FunctionArgumentWrapper<ExpressionBody>;
 
 // Function arguments are zero or more comma-separated arguments.
-struct FunctionArguments : PXR_PEGTL_NAMESPACE::internal::sor<list<FunctionArgument, one<','>, one<' '>>, PXR_PEGTL_NAMESPACE::internal::star<one<' '>>> {};
+struct FunctionArguments : sor<list<FunctionArgument, one<','>, one<' '>>, star<one<' '>>> {};
 
 struct Function
-    : PXR_PEGTL_NAMESPACE::internal::if_must<PXR_PEGTL_NAMESPACE::internal::seq<FunctionName, FunctionArgumentStart>, FunctionArguments, FunctionArgumentEnd> {};
+    : if_must<seq<FunctionName, FunctionArgumentStart>, FunctionArguments, FunctionArgumentEnd> {};
 
 // ----------------------------------------
 
 struct ScalarExpression
-    : PXR_PEGTL_NAMESPACE::internal::sor<Variable, DoubleQuotedString, SingleQuotedString, Integer, Boolean, None, Function> {};
+    : sor<Variable, DoubleQuotedString, SingleQuotedString, Integer, Boolean, None, Function> {};
 
 // ----------------------------------------
 
@@ -389,19 +391,19 @@ struct ListEnd : one<']'> {};
 
 struct ListElement : public ScalarExpression {};
 
-struct ListElements : PXR_PEGTL_NAMESPACE::internal::sor<list<ListElement, one<','>, one<' '>>, PXR_PEGTL_NAMESPACE::internal::star<one<' '>>> {};
+struct ListElements : sor<list<ListElement, one<','>, one<' '>>, star<one<' '>>> {};
 
-struct ListExpression : PXR_PEGTL_NAMESPACE::internal::if_must<ListStart, ListElements, ListEnd> {};
+struct ListExpression : if_must<ListStart, ListElements, ListEnd> {};
 
 // ----------------------------------------
 
-struct ExpressionStart : PXR_PEGTL_NAMESPACE::ascii::string<'`'> {};
+struct ExpressionStart : string<'`'> {};
 
-struct ExpressionEnd : PXR_PEGTL_NAMESPACE::ascii::string<'`'> {};
+struct ExpressionEnd : string<'`'> {};
 
-struct ExpressionBody : PXR_PEGTL_NAMESPACE::internal::sor<ScalarExpression, ListExpression> {};
+struct ExpressionBody : sor<ScalarExpression, ListExpression> {};
 
-struct Expression : PXR_PEGTL_NAMESPACE::internal::must<ExpressionStart, ExpressionBody, ExpressionEnd> {};
+struct Expression : must<ExpressionStart, ExpressionBody, ExpressionEnd> {};
 
 // Parser actions ---------------------------------------------
 // Objects that define the actions to take when a parsing rule