LibJS: rename JS::DeclarationType => JS::DeclarationKind

Many other parsers call it with this name.

Also Type can be confusing in this context since the DeclarationType is
not the type (number, string, etc.) of the variables that are being
declared by the VariableDeclaration.

Libraries/LibJS/AST.cpp

···
 {
     RefPtr<BlockStatement> wrapper;
 
-    if (m_init && m_init->is_variable_declaration() && static_cast<const VariableDeclaration*>(m_init.ptr())->declaration_type() != DeclarationType::Var) {
+    if (m_init && m_init->is_variable_declaration() && static_cast<const VariableDeclaration*>(m_init.ptr())->declaration_kind() != DeclarationKind::Var) {
         wrapper = create_ast_node<BlockStatement>();
         interpreter.enter_scope(*wrapper, {}, ScopeType::Block);
     }
···
 Value VariableDeclaration::execute(Interpreter& interpreter) const
 {
     for (auto& declarator : m_declarations) {
-        interpreter.declare_variable(declarator.id().string(), m_declaration_type);
+        interpreter.declare_variable(declarator.id().string(), m_declaration_kind);
         if (auto* init = declarator.init()) {
             auto initalizer_result = init->execute(interpreter);
             if (interpreter.exception())
···
 
 void VariableDeclaration::dump(int indent) const
 {
-    const char* declaration_type_string = nullptr;
-    switch (m_declaration_type) {
-    case DeclarationType::Let:
-        declaration_type_string = "Let";
+    const char* declaration_kind_string = nullptr;
+    switch (m_declaration_kind) {
+    case DeclarationKind::Let:
+        declaration_kind_string = "Let";
         break;
-    case DeclarationType::Var:
-        declaration_type_string = "Var";
+    case DeclarationKind::Var:
+        declaration_kind_string = "Var";
         break;
-    case DeclarationType::Const:
-        declaration_type_string = "Const";
+    case DeclarationKind::Const:
+        declaration_kind_string = "Const";
         break;
     }
 
     ASTNode::dump(indent);
     print_indent(indent + 1);
-    printf("%s\n", declaration_type_string);
+    printf("%s\n", declaration_kind_string);
 
     for (auto& declarator : m_declarations)
         declarator.dump(indent + 1);

Libraries/LibJS/AST.h

···
     bool m_prefixed;
 };
 
-enum class DeclarationType {
+enum class DeclarationKind {
     Var,
     Let,
     Const,
···
 
 class VariableDeclaration : public Declaration {
 public:
-    VariableDeclaration(DeclarationType declaration_type, NonnullRefPtrVector<VariableDeclarator> declarations)
-        : m_declaration_type(declaration_type)
+    VariableDeclaration(DeclarationKind declaration_kind, NonnullRefPtrVector<VariableDeclarator> declarations)
+        : m_declaration_kind(declaration_kind)
         , m_declarations(move(declarations))
     {
     }
 
     virtual bool is_variable_declaration() const override { return true; }
-    DeclarationType declaration_type() const { return m_declaration_type; }
+    DeclarationKind declaration_kind() const { return m_declaration_kind; }
 
     virtual Value execute(Interpreter&) const override;
     virtual void dump(int indent) const override;
···
 private:
     virtual const char* class_name() const override { return "VariableDeclaration"; }
 
-    DeclarationType m_declaration_type;
+    DeclarationKind m_declaration_kind;
     NonnullRefPtrVector<VariableDeclarator> m_declarations;
 };
 

Libraries/LibJS/Forward.h

···
 class Shape;
 class Statement;
 class Value;
-enum class DeclarationType;
+enum class DeclarationKind;
 
 struct Argument;
 

Libraries/LibJS/Interpreter.cpp

···
 
 void Interpreter::enter_scope(const ScopeNode& scope_node, ArgumentVector arguments, ScopeType scope_type)
 {
-    HashMap<FlyString, Variable> scope_variables_with_declaration_type;
+    HashMap<FlyString, Variable> scope_variables_with_declaration_kind;
     for (auto& argument : arguments) {
-        scope_variables_with_declaration_type.set(argument.name, { argument.value, DeclarationType::Var });
+        scope_variables_with_declaration_kind.set(argument.name, { argument.value, DeclarationKind::Var });
     }
-    m_scope_stack.append({ scope_type, scope_node, move(scope_variables_with_declaration_type) });
+    m_scope_stack.append({ scope_type, scope_node, move(scope_variables_with_declaration_kind) });
 }
 
 void Interpreter::exit_scope(const ScopeNode& scope_node)
···
         m_unwind_until = ScopeType::None;
 }
 
-void Interpreter::declare_variable(const FlyString& name, DeclarationType declaration_type)
+void Interpreter::declare_variable(const FlyString& name, DeclarationKind declaration_kind)
 {
-    switch (declaration_type) {
-    case DeclarationType::Var:
+    switch (declaration_kind) {
+    case DeclarationKind::Var:
         for (ssize_t i = m_scope_stack.size() - 1; i >= 0; --i) {
             auto& scope = m_scope_stack.at(i);
             if (scope.type == ScopeType::Function) {
-                if (scope.variables.get(name).has_value() && scope.variables.get(name).value().declaration_type != DeclarationType::Var)
+                if (scope.variables.get(name).has_value() && scope.variables.get(name).value().declaration_kind != DeclarationKind::Var)
                     ASSERT_NOT_REACHED();
 
-                scope.variables.set(move(name), { js_undefined(), declaration_type });
+                scope.variables.set(move(name), { js_undefined(), declaration_kind });
                 return;
             }
         }
 
         global_object().put(move(name), js_undefined());
         break;
-    case DeclarationType::Let:
-    case DeclarationType::Const:
+    case DeclarationKind::Let:
+    case DeclarationKind::Const:
         if (m_scope_stack.last().variables.get(name).has_value())
             ASSERT_NOT_REACHED();
 
-        m_scope_stack.last().variables.set(move(name), { js_undefined(), declaration_type });
+        m_scope_stack.last().variables.set(move(name), { js_undefined(), declaration_kind });
         break;
     }
 }
···
 
         auto possible_match = scope.variables.get(name);
         if (possible_match.has_value()) {
-            if (!first_assignment && possible_match.value().declaration_type == DeclarationType::Const)
+            if (!first_assignment && possible_match.value().declaration_kind == DeclarationKind::Const)
                 ASSERT_NOT_REACHED();
 
-            scope.variables.set(move(name), { move(value), possible_match.value().declaration_type });
+            scope.variables.set(move(name), { move(value), possible_match.value().declaration_kind });
             return;
         }
     }

Libraries/LibJS/Interpreter.h

···
 
 struct Variable {
     Value value;
-    DeclarationType declaration_type;
+    DeclarationKind declaration_kind;
 };
 
 struct ScopeFrame {
···
 
     Optional<Value> get_variable(const FlyString& name);
     void set_variable(const FlyString& name, Value, bool first_assignment = false);
-    void declare_variable(const FlyString& name, DeclarationType);
+    void declare_variable(const FlyString& name, DeclarationKind);
 
     void gather_roots(Badge<Heap>, HashTable<Cell*>&);
 

Libraries/LibJS/Parser.cpp

···
 
 NonnullRefPtr<VariableDeclaration> Parser::parse_variable_declaration()
 {
-    DeclarationType declaration_type;
+    DeclarationKind declaration_kind;
 
     switch (m_parser_state.m_current_token.type()) {
     case TokenType::Var:
-        declaration_type = DeclarationType::Var;
+        declaration_kind = DeclarationKind::Var;
         consume(TokenType::Var);
         break;
     case TokenType::Let:
-        declaration_type = DeclarationType::Let;
+        declaration_kind = DeclarationKind::Let;
         consume(TokenType::Let);
         break;
     case TokenType::Const:
-        declaration_type = DeclarationType::Const;
+        declaration_kind = DeclarationKind::Const;
         consume(TokenType::Const);
         break;
     default:
···
         }
         break;
     }
-    return create_ast_node<VariableDeclaration>(declaration_type, move(declarations));
+    return create_ast_node<VariableDeclaration>(declaration_kind, move(declarations));
 }
 
 NonnullRefPtr<ThrowStatement> Parser::parse_throw_statement()