ErlangTypes.java

// This is a generated file. Not intended for manual editing.
package org.intellij.erlang;

import com.intellij.psi.tree.IElementType;
import com.intellij.psi.PsiElement;
import com.intellij.lang.ASTNode;
import org.intellij.erlang.psi.ErlangCompositeElementType;
import org.intellij.erlang.psi.ErlangTokenType;
import org.intellij.erlang.psi.impl.*;

public interface ErlangTypes {

  IElementType ERL_ADDITIVE_EXPRESSION = new ErlangCompositeElementType("ERL_ADDITIVE_EXPRESSION");
  IElementType ERL_AFTER_CLAUSE_BODY = new ErlangCompositeElementType("ERL_AFTER_CLAUSE_BODY");
  IElementType ERL_ANDALSO_EXPRESSION = new ErlangCompositeElementType("ERL_ANDALSO_EXPRESSION");
  IElementType ERL_ANONYMOUS_CALL_EXPRESSION = new ErlangCompositeElementType("ERL_ANONYMOUS_CALL_EXPRESSION");
  IElementType ERL_ARGUMENT_DEFINITION = new ErlangCompositeElementType("ERL_ARGUMENT_DEFINITION");
  IElementType ERL_ARGUMENT_DEFINITION_LIST = new ErlangCompositeElementType("ERL_ARGUMENT_DEFINITION_LIST");
  IElementType ERL_ARGUMENT_LIST = new ErlangCompositeElementType("ERL_ARGUMENT_LIST");
  IElementType ERL_ASSIGNMENT_EXPRESSION = new ErlangCompositeElementType("ERL_ASSIGNMENT_EXPRESSION");
  IElementType ERL_ATOM = new ErlangCompositeElementType("ERL_ATOM");
  IElementType ERL_ATOM_ATTRIBUTE = new ErlangCompositeElementType("ERL_ATOM_ATTRIBUTE");
  IElementType ERL_ATOM_WITH_ARITY_EXPRESSION = new ErlangCompositeElementType("ERL_ATOM_WITH_ARITY_EXPRESSION");
  IElementType ERL_ATTRIBUTE = new ErlangCompositeElementType("ERL_ATTRIBUTE");
  IElementType ERL_ATTR_VAL = new ErlangCompositeElementType("ERL_ATTR_VAL");
  IElementType ERL_BEGIN_END_BODY = new ErlangCompositeElementType("ERL_BEGIN_END_BODY");
  IElementType ERL_BEGIN_END_EXPRESSION = new ErlangCompositeElementType("ERL_BEGIN_END_EXPRESSION");
  IElementType ERL_BEHAVIOUR = ErlangElementTypeFactory.factory("ERL_BEHAVIOUR");
  IElementType ERL_BINARY_EXPRESSION = new ErlangCompositeElementType("ERL_BINARY_EXPRESSION");
  IElementType ERL_BINARY_TYPE = new ErlangCompositeElementType("ERL_BINARY_TYPE");
  IElementType ERL_BIN_BASE_TYPE = new ErlangCompositeElementType("ERL_BIN_BASE_TYPE");
  IElementType ERL_BIN_ELEMENT = new ErlangCompositeElementType("ERL_BIN_ELEMENT");
  IElementType ERL_BIN_UNIT_TYPE = new ErlangCompositeElementType("ERL_BIN_UNIT_TYPE");
  IElementType ERL_BIT_TYPE = new ErlangCompositeElementType("ERL_BIT_TYPE");
  IElementType ERL_CALLBACK_FUNCTION = ErlangElementTypeFactory.factory("ERL_CALLBACK_FUNCTION");
  IElementType ERL_CALLBACK_SPEC = ErlangElementTypeFactory.factory("ERL_CALLBACK_SPEC");
  IElementType ERL_CASE_EXPRESSION = new ErlangCompositeElementType("ERL_CASE_EXPRESSION");
  IElementType ERL_CATCH_EXPRESSION = new ErlangCompositeElementType("ERL_CATCH_EXPRESSION");
  IElementType ERL_CLAUSE_BODY = new ErlangCompositeElementType("ERL_CLAUSE_BODY");
  IElementType ERL_CLAUSE_GUARD = new ErlangCompositeElementType("ERL_CLAUSE_GUARD");
  IElementType ERL_COLON_QUALIFIED_EXPRESSION = new ErlangCompositeElementType("ERL_COLON_QUALIFIED_EXPRESSION");
  IElementType ERL_COMP_OP_EXPRESSION = new ErlangCompositeElementType("ERL_COMP_OP_EXPRESSION");
  IElementType ERL_CONFIG_CALL_EXPRESSION = new ErlangCompositeElementType("ERL_CONFIG_CALL_EXPRESSION");
  IElementType ERL_CONFIG_EXPRESSION = new ErlangCompositeElementType("ERL_CONFIG_EXPRESSION");
  IElementType ERL_CR_CLAUSE = new ErlangCompositeElementType("ERL_CR_CLAUSE");
  IElementType ERL_EXPORT = new ErlangCompositeElementType("ERL_EXPORT");
  IElementType ERL_EXPORT_FUNCTION = new ErlangCompositeElementType("ERL_EXPORT_FUNCTION");
  IElementType ERL_EXPORT_FUNCTIONS = new ErlangCompositeElementType("ERL_EXPORT_FUNCTIONS");
  IElementType ERL_EXPORT_TYPE = new ErlangCompositeElementType("ERL_EXPORT_TYPE");
  IElementType ERL_EXPORT_TYPES = new ErlangCompositeElementType("ERL_EXPORT_TYPES");
  IElementType ERL_EXPORT_TYPE_ATTRIBUTE = new ErlangCompositeElementType("ERL_EXPORT_TYPE_ATTRIBUTE");
  IElementType ERL_EXPRESSION = new ErlangCompositeElementType("ERL_EXPRESSION");
  IElementType ERL_FIELD_TYPE = new ErlangCompositeElementType("ERL_FIELD_TYPE");
  IElementType ERL_FUNCTION = ErlangElementTypeFactory.factory("ERL_FUNCTION");
  IElementType ERL_FUNCTION_CALL_EXPRESSION = new ErlangCompositeElementType("ERL_FUNCTION_CALL_EXPRESSION");
  IElementType ERL_FUNCTION_CLAUSE = new ErlangCompositeElementType("ERL_FUNCTION_CLAUSE");
  IElementType ERL_FUNCTION_WITH_ARITY = new ErlangCompositeElementType("ERL_FUNCTION_WITH_ARITY");
  IElementType ERL_FUNCTION_WITH_ARITY_VARIABLES = new ErlangCompositeElementType("ERL_FUNCTION_WITH_ARITY_VARIABLES");
  IElementType ERL_FUN_CLAUSE = new ErlangCompositeElementType("ERL_FUN_CLAUSE");
  IElementType ERL_FUN_CLAUSES = new ErlangCompositeElementType("ERL_FUN_CLAUSES");
  IElementType ERL_FUN_EXPRESSION = new ErlangCompositeElementType("ERL_FUN_EXPRESSION");
  IElementType ERL_FUN_TYPE = new ErlangCompositeElementType("ERL_FUN_TYPE");
  IElementType ERL_FUN_TYPE_100_T = new ErlangCompositeElementType("ERL_FUN_TYPE_100_T");
  IElementType ERL_FUN_TYPE_ARGUMENTS = new ErlangCompositeElementType("ERL_FUN_TYPE_ARGUMENTS");
  IElementType ERL_FUN_TYPE_SIGS = new ErlangCompositeElementType("ERL_FUN_TYPE_SIGS");
  IElementType ERL_FUN_TYPE_SIGS_BRACES = new ErlangCompositeElementType("ERL_FUN_TYPE_SIGS_BRACES");
  IElementType ERL_GENERIC_FUNCTION_CALL_EXPRESSION = new ErlangCompositeElementType("ERL_GENERIC_FUNCTION_CALL_EXPRESSION");
  IElementType ERL_GLOBAL_FUNCTION_CALL_EXPRESSION = new ErlangCompositeElementType("ERL_GLOBAL_FUNCTION_CALL_EXPRESSION");
  IElementType ERL_GUARD = new ErlangCompositeElementType("ERL_GUARD");
  IElementType ERL_IF_CLAUSE = new ErlangCompositeElementType("ERL_IF_CLAUSE");
  IElementType ERL_IF_EXPRESSION = new ErlangCompositeElementType("ERL_IF_EXPRESSION");
  IElementType ERL_IMPORT_DIRECTIVE = new ErlangCompositeElementType("ERL_IMPORT_DIRECTIVE");
  IElementType ERL_IMPORT_FUNCTION = new ErlangCompositeElementType("ERL_IMPORT_FUNCTION");
  IElementType ERL_IMPORT_FUNCTIONS = new ErlangCompositeElementType("ERL_IMPORT_FUNCTIONS");
  IElementType ERL_INCLUDE = ErlangElementTypeFactory.factory("ERL_INCLUDE");
  IElementType ERL_INCLUDE_LIB = ErlangElementTypeFactory.factory("ERL_INCLUDE_LIB");
  IElementType ERL_INCLUDE_STRING = new ErlangCompositeElementType("ERL_INCLUDE_STRING");
  IElementType ERL_INT_TYPE = new ErlangCompositeElementType("ERL_INT_TYPE");
  IElementType ERL_LC_EXPRESSION = new ErlangCompositeElementType("ERL_LC_EXPRESSION");
  IElementType ERL_LIST_COMPREHENSION = new ErlangCompositeElementType("ERL_LIST_COMPREHENSION");
  IElementType ERL_LIST_EXPRESSION = new ErlangCompositeElementType("ERL_LIST_EXPRESSION");
  IElementType ERL_LIST_OP_EXPRESSION = new ErlangCompositeElementType("ERL_LIST_OP_EXPRESSION");
  IElementType ERL_MACROS = new ErlangCompositeElementType("ERL_MACROS");
  IElementType ERL_MACROS_ARG = new ErlangCompositeElementType("ERL_MACROS_ARG");
  IElementType ERL_MACROS_BODY = new ErlangCompositeElementType("ERL_MACROS_BODY");
  IElementType ERL_MACROS_CALL = new ErlangCompositeElementType("ERL_MACROS_CALL");
  IElementType ERL_MACROS_DEFINITION = ErlangElementTypeFactory.factory("ERL_MACROS_DEFINITION");
  IElementType ERL_MACROS_NAME = new ErlangCompositeElementType("ERL_MACROS_NAME");
  IElementType ERL_MAP_ENTRY = new ErlangCompositeElementType("ERL_MAP_ENTRY");
  IElementType ERL_MAP_ENTRY_TYPE = new ErlangCompositeElementType("ERL_MAP_ENTRY_TYPE");
  IElementType ERL_MAP_EXPRESSION = new ErlangCompositeElementType("ERL_MAP_EXPRESSION");
  IElementType ERL_MAP_TUPLE = new ErlangCompositeElementType("ERL_MAP_TUPLE");
  IElementType ERL_MAP_TYPE = new ErlangCompositeElementType("ERL_MAP_TYPE");
  IElementType ERL_MAX_EXPRESSION = new ErlangCompositeElementType("ERL_MAX_EXPRESSION");
  IElementType ERL_MODEL_FIELD_LIST = new ErlangCompositeElementType("ERL_MODEL_FIELD_LIST");
  IElementType ERL_MODULE = ErlangElementTypeFactory.factory("ERL_MODULE");
  IElementType ERL_MODULE_REF = new ErlangCompositeElementType("ERL_MODULE_REF");
  IElementType ERL_MULTIPLICATIVE_EXPRESSION = new ErlangCompositeElementType("ERL_MULTIPLICATIVE_EXPRESSION");
  IElementType ERL_OPTIONAL_CALLBACKS = new ErlangCompositeElementType("ERL_OPTIONAL_CALLBACKS");
  IElementType ERL_OPTIONAL_CALLBACK_FUNCTIONS = new ErlangCompositeElementType("ERL_OPTIONAL_CALLBACK_FUNCTIONS");
  IElementType ERL_OPT_BIT_TYPE_LIST = new ErlangCompositeElementType("ERL_OPT_BIT_TYPE_LIST");
  IElementType ERL_ORELSE_EXPRESSION = new ErlangCompositeElementType("ERL_ORELSE_EXPRESSION");
  IElementType ERL_PARENTHESIZED_EXPRESSION = new ErlangCompositeElementType("ERL_PARENTHESIZED_EXPRESSION");
  IElementType ERL_PREFIX_EXPRESSION = new ErlangCompositeElementType("ERL_PREFIX_EXPRESSION");
  IElementType ERL_QUALIFIED_EXPRESSION = new ErlangCompositeElementType("ERL_QUALIFIED_EXPRESSION");
  IElementType ERL_Q_ATOM = new ErlangCompositeElementType("ERL_Q_ATOM");
  IElementType ERL_Q_VAR = new ErlangCompositeElementType("ERL_Q_VAR");
  IElementType ERL_RECEIVE_EXPRESSION = new ErlangCompositeElementType("ERL_RECEIVE_EXPRESSION");
  IElementType ERL_RECORD_DEFINITION = ErlangElementTypeFactory.factory("ERL_RECORD_DEFINITION");
  IElementType ERL_RECORD_EXPRESSION = new ErlangCompositeElementType("ERL_RECORD_EXPRESSION");
  IElementType ERL_RECORD_FIELD = new ErlangCompositeElementType("ERL_RECORD_FIELD");
  IElementType ERL_RECORD_LIKE_TYPE = new ErlangCompositeElementType("ERL_RECORD_LIKE_TYPE");
  IElementType ERL_RECORD_REF = new ErlangCompositeElementType("ERL_RECORD_REF");
  IElementType ERL_RECORD_TUPLE = new ErlangCompositeElementType("ERL_RECORD_TUPLE");
  IElementType ERL_RULE = new ErlangCompositeElementType("ERL_RULE");
  IElementType ERL_RULE_BODY = new ErlangCompositeElementType("ERL_RULE_BODY");
  IElementType ERL_RULE_CLAUSE = new ErlangCompositeElementType("ERL_RULE_CLAUSE");
  IElementType ERL_SEND_EXPRESSION = new ErlangCompositeElementType("ERL_SEND_EXPRESSION");
  IElementType ERL_SPECIFICATION = ErlangElementTypeFactory.factory("ERL_SPECIFICATION");
  IElementType ERL_SPEC_FUN = new ErlangCompositeElementType("ERL_SPEC_FUN");
  IElementType ERL_STRING_LITERAL = new ErlangCompositeElementType("ERL_STRING_LITERAL");
  IElementType ERL_TOP_TYPE = new ErlangCompositeElementType("ERL_TOP_TYPE");
  IElementType ERL_TOP_TYPE_CLAUSE = new ErlangCompositeElementType("ERL_TOP_TYPE_CLAUSE");
  IElementType ERL_TRY_CLAUSE = new ErlangCompositeElementType("ERL_TRY_CLAUSE");
  IElementType ERL_TRY_CLAUSES = new ErlangCompositeElementType("ERL_TRY_CLAUSES");
  IElementType ERL_TRY_EXPRESSION = new ErlangCompositeElementType("ERL_TRY_EXPRESSION");
  IElementType ERL_TRY_EXPRESSIONS_CLAUSE = new ErlangCompositeElementType("ERL_TRY_EXPRESSIONS_CLAUSE");
  IElementType ERL_TUPLE_EXPRESSION = new ErlangCompositeElementType("ERL_TUPLE_EXPRESSION");
  IElementType ERL_TYPE = new ErlangCompositeElementType("ERL_TYPE");
  IElementType ERL_TYPED_ATTR_VAL = new ErlangCompositeElementType("ERL_TYPED_ATTR_VAL");
  IElementType ERL_TYPED_EXPR = new ErlangCompositeElementType("ERL_TYPED_EXPR");
  IElementType ERL_TYPED_RECORD_FIELDS = new ErlangCompositeElementType("ERL_TYPED_RECORD_FIELDS");
  IElementType ERL_TYPE_DEFINITION = ErlangElementTypeFactory.factory("ERL_TYPE_DEFINITION");
  IElementType ERL_TYPE_GUARD = new ErlangCompositeElementType("ERL_TYPE_GUARD");
  IElementType ERL_TYPE_REF = new ErlangCompositeElementType("ERL_TYPE_REF");
  IElementType ERL_TYPE_SIG = new ErlangCompositeElementType("ERL_TYPE_SIG");
  IElementType ERL_TYPE_SIG_GUARD = new ErlangCompositeElementType("ERL_TYPE_SIG_GUARD");

  IElementType ERL_AFTER = new ErlangTokenType("after");
  IElementType ERL_AND = new ErlangTokenType("and");
  IElementType ERL_ANDALSO = new ErlangTokenType("andalso");
  IElementType ERL_ARROW = new ErlangTokenType("->");
  IElementType ERL_ASSOC = new ErlangTokenType("=>");
  IElementType ERL_ATOM_NAME = new ErlangTokenType("atom_name");
  IElementType ERL_BAND = new ErlangTokenType("band");
  IElementType ERL_BEGIN = new ErlangTokenType("begin");
  IElementType ERL_BIN_END = new ErlangTokenType(">>");
  IElementType ERL_BIN_START = new ErlangTokenType("<<");
  IElementType ERL_BNOT = new ErlangTokenType("bnot");
  IElementType ERL_BOR = new ErlangTokenType("bor");
  IElementType ERL_BRACKET_LEFT = new ErlangTokenType("[");
  IElementType ERL_BRACKET_RIGHT = new ErlangTokenType("]");
  IElementType ERL_BSL = new ErlangTokenType("bsl");
  IElementType ERL_BSR = new ErlangTokenType("bsr");
  IElementType ERL_BXOR = new ErlangTokenType("bxor");
  IElementType ERL_CASE = new ErlangTokenType("case");
  IElementType ERL_CATCH = new ErlangTokenType("catch");
  IElementType ERL_CHAR = new ErlangTokenType("char");
  IElementType ERL_COLON = new ErlangTokenType(":");
  IElementType ERL_COLON_COLON = new ErlangTokenType("::");
  IElementType ERL_COMMA = new ErlangTokenType(",");
  IElementType ERL_CURLY_LEFT = new ErlangTokenType("{");
  IElementType ERL_CURLY_RIGHT = new ErlangTokenType("}");
  IElementType ERL_DIV = new ErlangTokenType("div");
  IElementType ERL_DOT = new ErlangTokenType(".");
  IElementType ERL_DOT_DOT = new ErlangTokenType("..");
  IElementType ERL_DOT_DOT_DOT = new ErlangTokenType("...");
  IElementType ERL_END = new ErlangTokenType("end");
  IElementType ERL_FLOAT = new ErlangTokenType("float");
  IElementType ERL_FUN = new ErlangTokenType("fun");
  IElementType ERL_IF = new ErlangTokenType("if");
  IElementType ERL_INTEGER = new ErlangTokenType("integer");
  IElementType ERL_MATCH = new ErlangTokenType(":=");
  IElementType ERL_NOT = new ErlangTokenType("not");
  IElementType ERL_OF = new ErlangTokenType("of");
  IElementType ERL_OP_AR_DIV = new ErlangTokenType("/");
  IElementType ERL_OP_AR_MUL = new ErlangTokenType("*");
  IElementType ERL_OP_DIV_EQ = new ErlangTokenType("/=");
  IElementType ERL_OP_EQ = new ErlangTokenType("=");
  IElementType ERL_OP_EQ_COL_EQ = new ErlangTokenType("=:=");
  IElementType ERL_OP_EQ_DIV_EQ = new ErlangTokenType("=/=");
  IElementType ERL_OP_EQ_EQ = new ErlangTokenType("==");
  IElementType ERL_OP_EQ_LT = new ErlangTokenType("=<");
  IElementType ERL_OP_EXL = new ErlangTokenType("!");
  IElementType ERL_OP_GT = new ErlangTokenType(">");
  IElementType ERL_OP_GT_EQ = new ErlangTokenType(">=");
  IElementType ERL_OP_LT = new ErlangTokenType("<");
  IElementType ERL_OP_LT_EQ = new ErlangTokenType("<=");
  IElementType ERL_OP_LT_MINUS = new ErlangTokenType("<-");
  IElementType ERL_OP_MINUS = new ErlangTokenType("-");
  IElementType ERL_OP_MINUS_MINUS = new ErlangTokenType("--");
  IElementType ERL_OP_OR = new ErlangTokenType("|");
  IElementType ERL_OP_PLUS = new ErlangTokenType("+");
  IElementType ERL_OP_PLUS_PLUS = new ErlangTokenType("++");
  IElementType ERL_OR = new ErlangTokenType("or");
  IElementType ERL_ORELSE = new ErlangTokenType("orelse");
  IElementType ERL_OR_OR = new ErlangTokenType("||");
  IElementType ERL_PAR_LEFT = new ErlangTokenType("(");
  IElementType ERL_PAR_RIGHT = new ErlangTokenType(")");
  IElementType ERL_QMARK = new ErlangTokenType("?");
  IElementType ERL_RADIX = new ErlangTokenType("#");
  IElementType ERL_RECEIVE = new ErlangTokenType("receive");
  IElementType ERL_REM = new ErlangTokenType("rem");
  IElementType ERL_SEMI = new ErlangTokenType(";");
  IElementType ERL_SINGLE_QUOTE = new ErlangTokenType("single_quote");
  IElementType ERL_STRING = new ErlangTokenType("string");
  IElementType ERL_TRY = new ErlangTokenType("try");
  IElementType ERL_VAR = new ErlangTokenType("var");
  IElementType ERL_WHEN = new ErlangTokenType("when");
  IElementType ERL_XOR = new ErlangTokenType("xor");

  class Factory {
    public static PsiElement createElement(ASTNode node) {
      IElementType type = node.getElementType();
       if (type == ERL_ADDITIVE_EXPRESSION) {
        return new ErlangAdditiveExpressionImpl(node);
      }
      else if (type == ERL_AFTER_CLAUSE_BODY) {
        return new ErlangAfterClauseBodyImpl(node);
      }
      else if (type == ERL_ANDALSO_EXPRESSION) {
        return new ErlangAndalsoExpressionImpl(node);
      }
      else if (type == ERL_ANONYMOUS_CALL_EXPRESSION) {
        return new ErlangAnonymousCallExpressionImpl(node);
      }
      else if (type == ERL_ARGUMENT_DEFINITION) {
        return new ErlangArgumentDefinitionImpl(node);
      }
      else if (type == ERL_ARGUMENT_DEFINITION_LIST) {
        return new ErlangArgumentDefinitionListImpl(node);
      }
      else if (type == ERL_ARGUMENT_LIST) {
        return new ErlangArgumentListImpl(node);
      }
      else if (type == ERL_ASSIGNMENT_EXPRESSION) {
        return new ErlangAssignmentExpressionImpl(node);
      }
      else if (type == ERL_ATOM) {
        return new ErlangAtomImpl(node);
      }
      else if (type == ERL_ATOM_ATTRIBUTE) {
        return new ErlangAtomAttributeImpl(node);
      }
      else if (type == ERL_ATOM_WITH_ARITY_EXPRESSION) {
        return new ErlangAtomWithArityExpressionImpl(node);
      }
      else if (type == ERL_ATTRIBUTE) {
        return new ErlangAttributeImpl(node);
      }
      else if (type == ERL_ATTR_VAL) {
        return new ErlangAttrValImpl(node);
      }
      else if (type == ERL_BEGIN_END_BODY) {
        return new ErlangBeginEndBodyImpl(node);
      }
      else if (type == ERL_BEGIN_END_EXPRESSION) {
        return new ErlangBeginEndExpressionImpl(node);
      }
      else if (type == ERL_BEHAVIOUR) {
        return new ErlangBehaviourImpl(node);
      }
      else if (type == ERL_BINARY_EXPRESSION) {
        return new ErlangBinaryExpressionImpl(node);
      }
      else if (type == ERL_BINARY_TYPE) {
        return new ErlangBinaryTypeImpl(node);
      }
      else if (type == ERL_BIN_BASE_TYPE) {
        return new ErlangBinBaseTypeImpl(node);
      }
      else if (type == ERL_BIN_ELEMENT) {
        return new ErlangBinElementImpl(node);
      }
      else if (type == ERL_BIN_UNIT_TYPE) {
        return new ErlangBinUnitTypeImpl(node);
      }
      else if (type == ERL_BIT_TYPE) {
        return new ErlangBitTypeImpl(node);
      }
      else if (type == ERL_CALLBACK_FUNCTION) {
        return new ErlangCallbackFunctionImpl(node);
      }
      else if (type == ERL_CALLBACK_SPEC) {
        return new ErlangCallbackSpecImpl(node);
      }
      else if (type == ERL_CASE_EXPRESSION) {
        return new ErlangCaseExpressionImpl(node);
      }
      else if (type == ERL_CATCH_EXPRESSION) {
        return new ErlangCatchExpressionImpl(node);
      }
      else if (type == ERL_CLAUSE_BODY) {
        return new ErlangClauseBodyImpl(node);
      }
      else if (type == ERL_CLAUSE_GUARD) {
        return new ErlangClauseGuardImpl(node);
      }
      else if (type == ERL_COLON_QUALIFIED_EXPRESSION) {
        return new ErlangColonQualifiedExpressionImpl(node);
      }
      else if (type == ERL_COMP_OP_EXPRESSION) {
        return new ErlangCompOpExpressionImpl(node);
      }
      else if (type == ERL_CONFIG_CALL_EXPRESSION) {
        return new ErlangConfigCallExpressionImpl(node);
      }
      else if (type == ERL_CONFIG_EXPRESSION) {
        return new ErlangConfigExpressionImpl(node);
      }
      else if (type == ERL_CR_CLAUSE) {
        return new ErlangCrClauseImpl(node);
      }
      else if (type == ERL_EXPORT) {
        return new ErlangExportImpl(node);
      }
      else if (type == ERL_EXPORT_FUNCTION) {
        return new ErlangExportFunctionImpl(node);
      }
      else if (type == ERL_EXPORT_FUNCTIONS) {
        return new ErlangExportFunctionsImpl(node);
      }
      else if (type == ERL_EXPORT_TYPE) {
        return new ErlangExportTypeImpl(node);
      }
      else if (type == ERL_EXPORT_TYPES) {
        return new ErlangExportTypesImpl(node);
      }
      else if (type == ERL_EXPORT_TYPE_ATTRIBUTE) {
        return new ErlangExportTypeAttributeImpl(node);
      }
      else if (type == ERL_EXPRESSION) {
        return new ErlangExpressionImpl(node);
      }
      else if (type == ERL_FIELD_TYPE) {
        return new ErlangFieldTypeImpl(node);
      }
      else if (type == ERL_FUNCTION) {
        return new ErlangFunctionImpl(node);
      }
      else if (type == ERL_FUNCTION_CALL_EXPRESSION) {
        return new ErlangFunctionCallExpressionImpl(node);
      }
      else if (type == ERL_FUNCTION_CLAUSE) {
        return new ErlangFunctionClauseImpl(node);
      }
      else if (type == ERL_FUNCTION_WITH_ARITY) {
        return new ErlangFunctionWithArityImpl(node);
      }
      else if (type == ERL_FUNCTION_WITH_ARITY_VARIABLES) {
        return new ErlangFunctionWithArityVariablesImpl(node);
      }
      else if (type == ERL_FUN_CLAUSE) {
        return new ErlangFunClauseImpl(node);
      }
      else if (type == ERL_FUN_CLAUSES) {
        return new ErlangFunClausesImpl(node);
      }
      else if (type == ERL_FUN_EXPRESSION) {
        return new ErlangFunExpressionImpl(node);
      }
      else if (type == ERL_FUN_TYPE) {
        return new ErlangFunTypeImpl(node);
      }
      else if (type == ERL_FUN_TYPE_100_T) {
        return new ErlangFunType100TImpl(node);
      }
      else if (type == ERL_FUN_TYPE_ARGUMENTS) {
        return new ErlangFunTypeArgumentsImpl(node);
      }
      else if (type == ERL_FUN_TYPE_SIGS) {
        return new ErlangFunTypeSigsImpl(node);
      }
      else if (type == ERL_FUN_TYPE_SIGS_BRACES) {
        return new ErlangFunTypeSigsBracesImpl(node);
      }
      else if (type == ERL_GENERIC_FUNCTION_CALL_EXPRESSION) {
        return new ErlangGenericFunctionCallExpressionImpl(node);
      }
      else if (type == ERL_GLOBAL_FUNCTION_CALL_EXPRESSION) {
        return new ErlangGlobalFunctionCallExpressionImpl(node);
      }
      else if (type == ERL_GUARD) {
        return new ErlangGuardImpl(node);
      }
      else if (type == ERL_IF_CLAUSE) {
        return new ErlangIfClauseImpl(node);
      }
      else if (type == ERL_IF_EXPRESSION) {
        return new ErlangIfExpressionImpl(node);
      }
      else if (type == ERL_IMPORT_DIRECTIVE) {
        return new ErlangImportDirectiveImpl(node);
      }
      else if (type == ERL_IMPORT_FUNCTION) {
        return new ErlangImportFunctionImpl(node);
      }
      else if (type == ERL_IMPORT_FUNCTIONS) {
        return new ErlangImportFunctionsImpl(node);
      }
      else if (type == ERL_INCLUDE) {
        return new ErlangIncludeImpl(node);
      }
      else if (type == ERL_INCLUDE_LIB) {
        return new ErlangIncludeLibImpl(node);
      }
      else if (type == ERL_INCLUDE_STRING) {
        return new ErlangIncludeStringImpl(node);
      }
      else if (type == ERL_INT_TYPE) {
        return new ErlangIntTypeImpl(node);
      }
      else if (type == ERL_LC_EXPRESSION) {
        return new ErlangLcExpressionImpl(node);
      }
      else if (type == ERL_LIST_COMPREHENSION) {
        return new ErlangListComprehensionImpl(node);
      }
      else if (type == ERL_LIST_EXPRESSION) {
        return new ErlangListExpressionImpl(node);
      }
      else if (type == ERL_LIST_OP_EXPRESSION) {
        return new ErlangListOpExpressionImpl(node);
      }
      else if (type == ERL_MACROS) {
        return new ErlangMacrosImpl(node);
      }
      else if (type == ERL_MACROS_ARG) {
        return new ErlangMacrosArgImpl(node);
      }
      else if (type == ERL_MACROS_BODY) {
        return new ErlangMacrosBodyImpl(node);
      }
      else if (type == ERL_MACROS_CALL) {
        return new ErlangMacrosCallImpl(node);
      }
      else if (type == ERL_MACROS_DEFINITION) {
        return new ErlangMacrosDefinitionImpl(node);
      }
      else if (type == ERL_MACROS_NAME) {
        return new ErlangMacrosNameImpl(node);
      }
      else if (type == ERL_MAP_ENTRY) {
        return new ErlangMapEntryImpl(node);
      }
      else if (type == ERL_MAP_ENTRY_TYPE) {
        return new ErlangMapEntryTypeImpl(node);
      }
      else if (type == ERL_MAP_EXPRESSION) {
        return new ErlangMapExpressionImpl(node);
      }
      else if (type == ERL_MAP_TUPLE) {
        return new ErlangMapTupleImpl(node);
      }
      else if (type == ERL_MAP_TYPE) {
        return new ErlangMapTypeImpl(node);
      }
      else if (type == ERL_MAX_EXPRESSION) {
        return new ErlangMaxExpressionImpl(node);
      }
      else if (type == ERL_MODEL_FIELD_LIST) {
        return new ErlangModelFieldListImpl(node);
      }
      else if (type == ERL_MODULE) {
        return new ErlangModuleImpl(node);
      }
      else if (type == ERL_MODULE_REF) {
        return new ErlangModuleRefImpl(node);
      }
      else if (type == ERL_MULTIPLICATIVE_EXPRESSION) {
        return new ErlangMultiplicativeExpressionImpl(node);
      }
      else if (type == ERL_OPTIONAL_CALLBACKS) {
        return new ErlangOptionalCallbacksImpl(node);
      }
      else if (type == ERL_OPTIONAL_CALLBACK_FUNCTIONS) {
        return new ErlangOptionalCallbackFunctionsImpl(node);
      }
      else if (type == ERL_OPT_BIT_TYPE_LIST) {
        return new ErlangOptBitTypeListImpl(node);
      }
      else if (type == ERL_ORELSE_EXPRESSION) {
        return new ErlangOrelseExpressionImpl(node);
      }
      else if (type == ERL_PARENTHESIZED_EXPRESSION) {
        return new ErlangParenthesizedExpressionImpl(node);
      }
      else if (type == ERL_PREFIX_EXPRESSION) {
        return new ErlangPrefixExpressionImpl(node);
      }
      else if (type == ERL_QUALIFIED_EXPRESSION) {
        return new ErlangQualifiedExpressionImpl(node);
      }
      else if (type == ERL_Q_ATOM) {
        return new ErlangQAtomImpl(node);
      }
      else if (type == ERL_Q_VAR) {
        return new ErlangQVarImpl(node);
      }
      else if (type == ERL_RECEIVE_EXPRESSION) {
        return new ErlangReceiveExpressionImpl(node);
      }
      else if (type == ERL_RECORD_DEFINITION) {
        return new ErlangRecordDefinitionImpl(node);
      }
      else if (type == ERL_RECORD_EXPRESSION) {
        return new ErlangRecordExpressionImpl(node);
      }
      else if (type == ERL_RECORD_FIELD) {
        return new ErlangRecordFieldImpl(node);
      }
      else if (type == ERL_RECORD_LIKE_TYPE) {
        return new ErlangRecordLikeTypeImpl(node);
      }
      else if (type == ERL_RECORD_REF) {
        return new ErlangRecordRefImpl(node);
      }
      else if (type == ERL_RECORD_TUPLE) {
        return new ErlangRecordTupleImpl(node);
      }
      else if (type == ERL_RULE) {
        return new ErlangRuleImpl(node);
      }
      else if (type == ERL_RULE_BODY) {
        return new ErlangRuleBodyImpl(node);
      }
      else if (type == ERL_RULE_CLAUSE) {
        return new ErlangRuleClauseImpl(node);
      }
      else if (type == ERL_SEND_EXPRESSION) {
        return new ErlangSendExpressionImpl(node);
      }
      else if (type == ERL_SPECIFICATION) {
        return new ErlangSpecificationImpl(node);
      }
      else if (type == ERL_SPEC_FUN) {
        return new ErlangSpecFunImpl(node);
      }
      else if (type == ERL_STRING_LITERAL) {
        return new ErlangStringLiteralImpl(node);
      }
      else if (type == ERL_TOP_TYPE) {
        return new ErlangTopTypeImpl(node);
      }
      else if (type == ERL_TOP_TYPE_CLAUSE) {
        return new ErlangTopTypeClauseImpl(node);
      }
      else if (type == ERL_TRY_CLAUSE) {
        return new ErlangTryClauseImpl(node);
      }
      else if (type == ERL_TRY_CLAUSES) {
        return new ErlangTryClausesImpl(node);
      }
      else if (type == ERL_TRY_EXPRESSION) {
        return new ErlangTryExpressionImpl(node);
      }
      else if (type == ERL_TRY_EXPRESSIONS_CLAUSE) {
        return new ErlangTryExpressionsClauseImpl(node);
      }
      else if (type == ERL_TUPLE_EXPRESSION) {
        return new ErlangTupleExpressionImpl(node);
      }
      else if (type == ERL_TYPE) {
        return new ErlangTypeImpl(node);
      }
      else if (type == ERL_TYPED_ATTR_VAL) {
        return new ErlangTypedAttrValImpl(node);
      }
      else if (type == ERL_TYPED_EXPR) {
        return new ErlangTypedExprImpl(node);
      }
      else if (type == ERL_TYPED_RECORD_FIELDS) {
        return new ErlangTypedRecordFieldsImpl(node);
      }
      else if (type == ERL_TYPE_DEFINITION) {
        return new ErlangTypeDefinitionImpl(node);
      }
      else if (type == ERL_TYPE_GUARD) {
        return new ErlangTypeGuardImpl(node);
      }
      else if (type == ERL_TYPE_REF) {
        return new ErlangTypeRefImpl(node);
      }
      else if (type == ERL_TYPE_SIG) {
        return new ErlangTypeSigImpl(node);
      }
      else if (type == ERL_TYPE_SIG_GUARD) {
        return new ErlangTypeSigGuardImpl(node);
      }
      throw new AssertionError("Unknown element type: " + type);
    }
  }
}