diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index dc4328e..2c45704 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -179,8 +179,8 @@
   ast/variable.h
   ast/variable_decoration.cc
   ast/variable_decoration.h
-  ast/variable_statement.cc
-  ast/variable_statement.h
+  ast/variable_decl_statement.cc
+  ast/variable_decl_statement.h
   context.h
   context.cc
   reader/reader.cc
@@ -302,7 +302,7 @@
   ast/unary_method_expression_test.cc
   ast/unary_op_expression_test.cc
   ast/unless_statement_test.cc
-  ast/variable_statement_test.cc
+  ast/variable_decl_statement_test.cc
   ast/variable_test.cc
   type_manager_test.cc
   validator_impl_import_test.cc
@@ -458,7 +458,7 @@
     writer/wgsl/generator_impl_unary_method_test.cc
     writer/wgsl/generator_impl_unary_op_test.cc
     writer/wgsl/generator_impl_unless_test.cc
-    writer/wgsl/generator_impl_variable_statement_test.cc
+    writer/wgsl/generator_impl_variable_decl_statement_test.cc
     writer/wgsl/generator_impl_variable_test.cc
   )
 endif()
diff --git a/src/ast/statement.cc b/src/ast/statement.cc
index 07a1f09..1e2fa73 100644
--- a/src/ast/statement.cc
+++ b/src/ast/statement.cc
@@ -30,7 +30,7 @@
 #include "src/ast/return_statement.h"
 #include "src/ast/switch_statement.h"
 #include "src/ast/unless_statement.h"
-#include "src/ast/variable_statement.h"
+#include "src/ast/variable_decl_statement.h"
 
 namespace tint {
 namespace ast {
@@ -111,9 +111,9 @@
   return static_cast<UnlessStatement*>(this);
 }
 
-VariableStatement* Statement::AsVariable() {
-  assert(IsVariable());
-  return static_cast<VariableStatement*>(this);
+VariableDeclStatement* Statement::AsVariableDecl() {
+  assert(IsVariableDecl());
+  return static_cast<VariableDeclStatement*>(this);
 }
 
 }  // namespace ast
diff --git a/src/ast/statement.h b/src/ast/statement.h
index 112f580..d14ee31 100644
--- a/src/ast/statement.h
+++ b/src/ast/statement.h
@@ -34,7 +34,7 @@
 class ReturnStatement;
 class SwitchStatement;
 class UnlessStatement;
-class VariableStatement;
+class VariableDeclStatement;
 
 /// Base statement class
 class Statement : public Node {
@@ -70,7 +70,7 @@
   /// @returns true if this is an unless statement
   virtual bool IsUnless() const { return false; }
   /// @returns true if this is an variable statement
-  virtual bool IsVariable() const { return false; }
+  virtual bool IsVariableDecl() const { return false; }
 
   /// @returns the statement as an assign statement
   AssignmentStatement* AsAssign();
@@ -101,7 +101,7 @@
   /// @returns the statement as an unless statement
   UnlessStatement* AsUnless();
   /// @returns the statement as an variable statement
-  VariableStatement* AsVariable();
+  VariableDeclStatement* AsVariableDecl();
 
  protected:
   /// Constructor
diff --git a/src/ast/variable.h b/src/ast/variable.h
index 5a6c382..82148f5 100644
--- a/src/ast/variable.h
+++ b/src/ast/variable.h
@@ -30,7 +30,7 @@
 
 class DecoratedVariable;
 
-/// A Variable statement.
+/// A variable.
 class Variable : public Node {
  public:
   /// Create a new empty variable statement
diff --git a/src/ast/variable_statement.cc b/src/ast/variable_decl_statement.cc
similarity index 63%
rename from src/ast/variable_statement.cc
rename to src/ast/variable_decl_statement.cc
index ec88f5c..d8f8a84 100644
--- a/src/ast/variable_statement.cc
+++ b/src/ast/variable_decl_statement.cc
@@ -12,29 +12,29 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/ast/variable_statement.h"
+#include "src/ast/variable_decl_statement.h"
 
 namespace tint {
 namespace ast {
 
-VariableStatement::VariableStatement() : Statement() {}
+VariableDeclStatement::VariableDeclStatement() : Statement() {}
 
-VariableStatement::VariableStatement(std::unique_ptr<Variable> variable)
+VariableDeclStatement::VariableDeclStatement(std::unique_ptr<Variable> variable)
     : Statement(), variable_(std::move(variable)) {}
 
-VariableStatement::VariableStatement(const Source& source,
-                                     std::unique_ptr<Variable> variable)
+VariableDeclStatement::VariableDeclStatement(const Source& source,
+                                             std::unique_ptr<Variable> variable)
     : Statement(source), variable_(std::move(variable)) {}
 
-VariableStatement::~VariableStatement() = default;
+VariableDeclStatement::~VariableDeclStatement() = default;
 
-bool VariableStatement::IsValid() const {
+bool VariableDeclStatement::IsValid() const {
   return variable_ != nullptr && variable_->IsValid();
 }
 
-void VariableStatement::to_str(std::ostream& out, size_t indent) const {
+void VariableDeclStatement::to_str(std::ostream& out, size_t indent) const {
   make_indent(out, indent);
-  out << "VariableStatement{" << std::endl;
+  out << "VariableDeclStatement{" << std::endl;
   variable_->to_str(out, indent + 2);
   make_indent(out, indent);
   out << "}" << std::endl;
diff --git a/src/ast/variable_statement.h b/src/ast/variable_decl_statement.h
similarity index 72%
rename from src/ast/variable_statement.h
rename to src/ast/variable_decl_statement.h
index 51d2b6e..cb66061 100644
--- a/src/ast/variable_statement.h
+++ b/src/ast/variable_decl_statement.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_AST_VARIABLE_STATEMENT_H_
-#define SRC_AST_VARIABLE_STATEMENT_H_
+#ifndef SRC_AST_VARIABLE_DECL_STATEMENT_H_
+#define SRC_AST_VARIABLE_DECL_STATEMENT_H_
 
 #include <memory>
 #include <utility>
@@ -25,21 +25,22 @@
 namespace tint {
 namespace ast {
 
-/// A variable statement
-class VariableStatement : public Statement {
+/// A variable declaration statement
+class VariableDeclStatement : public Statement {
  public:
   /// Constructor
-  VariableStatement();
+  VariableDeclStatement();
   /// Constructor
   /// @param variable the variable
-  explicit VariableStatement(std::unique_ptr<Variable> variable);
+  explicit VariableDeclStatement(std::unique_ptr<Variable> variable);
   /// Constructor
   /// @param source the variable statement source
   /// @param variable the variable
-  VariableStatement(const Source& source, std::unique_ptr<Variable> variable);
+  VariableDeclStatement(const Source& source,
+                        std::unique_ptr<Variable> variable);
   /// Move constructor
-  VariableStatement(VariableStatement&&) = default;
-  ~VariableStatement() override;
+  VariableDeclStatement(VariableDeclStatement&&) = default;
+  ~VariableDeclStatement() override;
 
   /// Sets the variable
   /// @param variable the variable to set
@@ -50,7 +51,7 @@
   Variable* variable() const { return variable_.get(); }
 
   /// @returns true if this is an variable statement
-  bool IsVariable() const override { return true; }
+  bool IsVariableDecl() const override { return true; }
 
   /// @returns true if the node is valid
   bool IsValid() const override;
@@ -61,7 +62,7 @@
   void to_str(std::ostream& out, size_t indent) const override;
 
  private:
-  VariableStatement(const VariableStatement&) = delete;
+  VariableDeclStatement(const VariableDeclStatement&) = delete;
 
   std::unique_ptr<Variable> variable_;
 };
@@ -69,4 +70,4 @@
 }  // namespace ast
 }  // namespace tint
 
-#endif  // SRC_AST_VARIABLE_STATEMENT_H_
+#endif  // SRC_AST_VARIABLE_DECL_STATEMENT_H_
diff --git a/src/ast/variable_statement_test.cc b/src/ast/variable_decl_statement_test.cc
similarity index 65%
rename from src/ast/variable_statement_test.cc
rename to src/ast/variable_decl_statement_test.cc
index 5bc0eb7..84149c1 100644
--- a/src/ast/variable_statement_test.cc
+++ b/src/ast/variable_decl_statement_test.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/ast/variable_statement.h"
+#include "src/ast/variable_decl_statement.h"
 
 #include "gtest/gtest.h"
 #include "src/ast/type/f32_type.h"
@@ -22,59 +22,59 @@
 namespace ast {
 namespace {
 
-using VariableStatementTest = testing::Test;
+using VariableDeclStatementTest = testing::Test;
 
-TEST_F(VariableStatementTest, Creation) {
+TEST_F(VariableDeclStatementTest, Creation) {
   type::F32Type f32;
   auto var = std::make_unique<Variable>("a", StorageClass::kNone, &f32);
   auto var_ptr = var.get();
 
-  VariableStatement stmt(std::move(var));
+  VariableDeclStatement stmt(std::move(var));
   EXPECT_EQ(stmt.variable(), var_ptr);
 }
 
-TEST_F(VariableStatementTest, Creation_WithSource) {
+TEST_F(VariableDeclStatementTest, Creation_WithSource) {
   type::F32Type f32;
   auto var = std::make_unique<Variable>("a", StorageClass::kNone, &f32);
 
-  VariableStatement stmt(Source{20, 2}, std::move(var));
+  VariableDeclStatement stmt(Source{20, 2}, std::move(var));
   auto src = stmt.source();
   EXPECT_EQ(src.line, 20);
   EXPECT_EQ(src.column, 2);
 }
 
-TEST_F(VariableStatementTest, IsVariable) {
-  VariableStatement s;
-  EXPECT_TRUE(s.IsVariable());
+TEST_F(VariableDeclStatementTest, IsVariableDecl) {
+  VariableDeclStatement s;
+  EXPECT_TRUE(s.IsVariableDecl());
 }
 
-TEST_F(VariableStatementTest, IsValid) {
+TEST_F(VariableDeclStatementTest, IsValid) {
   type::F32Type f32;
   auto var = std::make_unique<Variable>("a", StorageClass::kNone, &f32);
-  VariableStatement stmt(std::move(var));
+  VariableDeclStatement stmt(std::move(var));
   EXPECT_TRUE(stmt.IsValid());
 }
 
-TEST_F(VariableStatementTest, IsValid_InvalidVariable) {
+TEST_F(VariableDeclStatementTest, IsValid_InvalidVariable) {
   type::F32Type f32;
   auto var = std::make_unique<Variable>("", StorageClass::kNone, &f32);
-  VariableStatement stmt(std::move(var));
+  VariableDeclStatement stmt(std::move(var));
   EXPECT_FALSE(stmt.IsValid());
 }
 
-TEST_F(VariableStatementTest, IsValid_NullVariable) {
-  VariableStatement stmt;
+TEST_F(VariableDeclStatementTest, IsValid_NullVariable) {
+  VariableDeclStatement stmt;
   EXPECT_FALSE(stmt.IsValid());
 }
 
-TEST_F(VariableStatementTest, ToStr) {
+TEST_F(VariableDeclStatementTest, ToStr) {
   type::F32Type f32;
   auto var = std::make_unique<Variable>("a", StorageClass::kNone, &f32);
 
-  VariableStatement stmt(Source{20, 2}, std::move(var));
+  VariableDeclStatement stmt(Source{20, 2}, std::move(var));
   std::ostringstream out;
   stmt.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  VariableStatement{
+  EXPECT_EQ(out.str(), R"(  VariableDeclStatement{
     Variable{
       a
       none
diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc
index ad795bb..61aeeab 100644
--- a/src/reader/wgsl/parser_impl.cc
+++ b/src/reader/wgsl/parser_impl.cc
@@ -63,7 +63,7 @@
 #include "src/ast/unary_method_expression.h"
 #include "src/ast/unary_op.h"
 #include "src/ast/unary_op_expression.h"
-#include "src/ast/variable_statement.h"
+#include "src/ast/variable_decl_statement.h"
 #include "src/reader/wgsl/lexer.h"
 #include "src/type_manager.h"
 
@@ -1667,7 +1667,7 @@
 //   : variable_decl
 //   | variable_decl EQUAL logical_or_expression
 //   | CONST variable_ident_decl EQUAL logical_or_expression
-std::unique_ptr<ast::VariableStatement> ParserImpl::variable_stmt() {
+std::unique_ptr<ast::VariableDeclStatement> ParserImpl::variable_stmt() {
   auto t = peek();
   auto source = t.source();
   if (t.IsConst()) {
@@ -1702,7 +1702,7 @@
     var->set_is_const(true);
     var->set_constructor(std::move(constructor));
 
-    return std::make_unique<ast::VariableStatement>(source, std::move(var));
+    return std::make_unique<ast::VariableDeclStatement>(source, std::move(var));
   }
 
   auto var = variable_decl();
@@ -1724,7 +1724,7 @@
     var->set_constructor(std::move(constructor));
   }
 
-  return std::make_unique<ast::VariableStatement>(source, std::move(var));
+  return std::make_unique<ast::VariableDeclStatement>(source, std::move(var));
 }
 
 // if_stmt
diff --git a/src/reader/wgsl/parser_impl.h b/src/reader/wgsl/parser_impl.h
index 22bfb7e..ad39e3d 100644
--- a/src/reader/wgsl/parser_impl.h
+++ b/src/reader/wgsl/parser_impl.h
@@ -201,7 +201,7 @@
   std::unique_ptr<ast::ContinueStatement> continue_stmt();
   /// Parses a `variable_stmt` grammar element
   /// @returns the parsed variable or nullptr
-  std::unique_ptr<ast::VariableStatement> variable_stmt();
+  std::unique_ptr<ast::VariableDeclStatement> variable_stmt();
   /// Parses a `if_stmt` grammar element
   /// @returns the parsed statement or nullptr
   std::unique_ptr<ast::IfStatement> if_stmt();
diff --git a/src/reader/wgsl/parser_impl_case_body_test.cc b/src/reader/wgsl/parser_impl_case_body_test.cc
index 98a9a91..d02a599 100644
--- a/src/reader/wgsl/parser_impl_case_body_test.cc
+++ b/src/reader/wgsl/parser_impl_case_body_test.cc
@@ -36,7 +36,7 @@
   auto e = p->case_body();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e.size(), 2);
-  EXPECT_TRUE(e[0]->IsVariable());
+  EXPECT_TRUE(e[0]->IsVariableDecl());
   EXPECT_TRUE(e[1]->IsAssign());
 }
 
diff --git a/src/reader/wgsl/parser_impl_statement_test.cc b/src/reader/wgsl/parser_impl_statement_test.cc
index 51082cc..bc047f3 100644
--- a/src/reader/wgsl/parser_impl_statement_test.cc
+++ b/src/reader/wgsl/parser_impl_statement_test.cc
@@ -130,7 +130,7 @@
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
-  ASSERT_TRUE(e->IsVariable());
+  ASSERT_TRUE(e->IsVariableDecl());
 }
 
 TEST_F(ParserImplTest, Statement_Variable_Invalid) {
diff --git a/src/reader/wgsl/parser_impl_variable_stmt_test.cc b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
index 8777380..78b7685 100644
--- a/src/reader/wgsl/parser_impl_variable_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
@@ -14,7 +14,7 @@
 
 #include "gtest/gtest.h"
 #include "src/ast/statement.h"
-#include "src/ast/variable_statement.h"
+#include "src/ast/variable_decl_statement.h"
 #include "src/reader/wgsl/parser_impl.h"
 #include "src/reader/wgsl/parser_impl_test_helper.h"
 
@@ -28,7 +28,7 @@
   auto e = p->variable_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
-  ASSERT_TRUE(e->IsVariable());
+  ASSERT_TRUE(e->IsVariableDecl());
   ASSERT_NE(e->variable(), nullptr);
   EXPECT_EQ(e->variable()->name(), "a");
 
@@ -40,7 +40,7 @@
   auto e = p->variable_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
-  ASSERT_TRUE(e->IsVariable());
+  ASSERT_TRUE(e->IsVariableDecl());
   ASSERT_NE(e->variable(), nullptr);
   EXPECT_EQ(e->variable()->name(), "a");
 
@@ -69,7 +69,7 @@
   auto e = p->variable_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
-  ASSERT_TRUE(e->IsVariable());
+  ASSERT_TRUE(e->IsVariableDecl());
 }
 
 TEST_F(ParserImplTest, VariableStmt_Const_InvalidVarIdent) {
diff --git a/src/writer/wgsl/generator_impl.cc b/src/writer/wgsl/generator_impl.cc
index d7bbf89..edc12bb 100644
--- a/src/writer/wgsl/generator_impl.cc
+++ b/src/writer/wgsl/generator_impl.cc
@@ -59,7 +59,7 @@
 #include "src/ast/unary_method_expression.h"
 #include "src/ast/unary_op_expression.h"
 #include "src/ast/unless_statement.h"
-#include "src/ast/variable_statement.h"
+#include "src/ast/variable_decl_statement.h"
 
 namespace tint {
 namespace writer {
@@ -752,8 +752,8 @@
   if (stmt->IsSwitch()) {
     return EmitSwitch(stmt->AsSwitch());
   }
-  if (stmt->IsVariable()) {
-    return EmitVariable(stmt->AsVariable()->variable());
+  if (stmt->IsVariableDecl()) {
+    return EmitVariable(stmt->AsVariableDecl()->variable());
   }
   if (stmt->IsUnless()) {
     return EmitUnless(stmt->AsUnless());
diff --git a/src/writer/wgsl/generator_impl_variable_statement_test.cc b/src/writer/wgsl/generator_impl_variable_decl_statement_test.cc
similarity index 88%
rename from src/writer/wgsl/generator_impl_variable_statement_test.cc
rename to src/writer/wgsl/generator_impl_variable_decl_statement_test.cc
index 13fdf97..f1797df 100644
--- a/src/writer/wgsl/generator_impl_variable_statement_test.cc
+++ b/src/writer/wgsl/generator_impl_variable_decl_statement_test.cc
@@ -18,7 +18,7 @@
 #include "gtest/gtest.h"
 #include "src/ast/type/f32_type.h"
 #include "src/ast/variable.h"
-#include "src/ast/variable_statement.h"
+#include "src/ast/variable_decl_statement.h"
 #include "src/writer/wgsl/generator_impl.h"
 
 namespace tint {
@@ -28,12 +28,12 @@
 
 using GeneratorImplTest = testing::Test;
 
-TEST_F(GeneratorImplTest, Emit_VariableStatement) {
+TEST_F(GeneratorImplTest, Emit_VariableDeclStatement) {
   ast::type::F32Type f32;
   auto var =
       std::make_unique<ast::Variable>("a", ast::StorageClass::kNone, &f32);
 
-  ast::VariableStatement stmt(std::move(var));
+  ast::VariableDeclStatement stmt(std::move(var));
 
   GeneratorImpl g;
   g.increment_indent();