Experimental meta static annotation removed

src/compiler/gravity_ast.c

@@ -13,7 +13,7 @@
 #include "gravity_visitor.h"
 #include "gravity_symboltable.h"
 
-#define SETBASE(node,tagv,_tok,_meta)   node->base.tag = tagv; node->base.token = _tok; node->base.meta = _meta
+#define SETBASE(node,tagv,_tok)         node->base.tag = tagv; node->base.token = _tok
 #define SETDECL(node,_decl)             node->base.decl = _decl
 #define CHECK_REFCOUNT(_node)           if (_node->base.refcount > 0) {--_node->base.refcount; return;}
 
@@ -101,7 +101,7 @@ gupvalue_t *gnode_function_add_upvalue(gnode_function_decl_t *f, gnode_var_t *sy
 gnode_t *gnode_jump_stat_create (gtoken_s token, gnode_t *expr, gnode_t *decl) {
     gnode_jump_stmt_t *node = (gnode_jump_stmt_t *)mem_alloc(NULL, sizeof(gnode_jump_stmt_t));
 
-    SETBASE(node, NODE_JUMP_STAT, token, NULL);
+    SETBASE(node, NODE_JUMP_STAT, token);
     SETDECL(node, decl);
     node->expr = expr;
     return (gnode_t *)node;
@@ -110,7 +110,7 @@ gnode_t *gnode_jump_stat_create (gtoken_s token, gnode_t *expr, gnode_t *decl) {
 gnode_t *gnode_label_stat_create (gtoken_s token, gnode_t *expr, gnode_t *stmt, gnode_t *decl) {
     gnode_label_stmt_t *node = (gnode_label_stmt_t *)mem_alloc(NULL, sizeof(gnode_label_stmt_t));
 
-    SETBASE(node, NODE_LABEL_STAT, token, NULL);
+    SETBASE(node, NODE_LABEL_STAT, token);
     SETDECL(node, decl);
     node->expr = expr;
     node->stmt = stmt;
@@ -120,7 +120,7 @@ gnode_t *gnode_label_stat_create (gtoken_s token, gnode_t *expr, gnode_t *stmt,
 gnode_t *gnode_flow_stat_create (gtoken_s token, gnode_t *cond, gnode_t *stmt1, gnode_t *stmt2, gnode_t *decl) {
     gnode_flow_stmt_t *node = (gnode_flow_stmt_t *)mem_alloc(NULL, sizeof(gnode_flow_stmt_t));
 
-    SETBASE(node, NODE_FLOW_STAT, token, NULL);
+    SETBASE(node, NODE_FLOW_STAT, token);
     SETDECL(node, decl);
     node->cond = cond;
     node->stmt = stmt1;
@@ -131,7 +131,7 @@ gnode_t *gnode_flow_stat_create (gtoken_s token, gnode_t *cond, gnode_t *stmt1,
 gnode_t *gnode_loop_stat_create (gtoken_s token, gnode_t *cond, gnode_t *stmt, gnode_t *expr, gnode_t *decl) {
     gnode_loop_stmt_t *node = (gnode_loop_stmt_t *)mem_alloc(NULL, sizeof(gnode_loop_stmt_t));
 
-    SETBASE(node, NODE_LOOP_STAT, token, NULL);
+    SETBASE(node, NODE_LOOP_STAT, token);
     SETDECL(node, decl);
     node->cond = cond;
     node->stmt = stmt;
@@ -143,7 +143,7 @@ gnode_t *gnode_loop_stat_create (gtoken_s token, gnode_t *cond, gnode_t *stmt, g
 gnode_t *gnode_block_stat_create (gnode_n type, gtoken_s token, gnode_r *stmts, gnode_t *decl) {
     gnode_compound_stmt_t *node = (gnode_compound_stmt_t *)mem_alloc(NULL, sizeof(gnode_compound_stmt_t));
 
-    SETBASE(node, type, token, NULL);
+    SETBASE(node, type, token);
     SETDECL(node, decl);
     node->stmts = stmts;
     node->nclose = UINT32_MAX;
@@ -153,7 +153,7 @@ gnode_t *gnode_block_stat_create (gnode_n type, gtoken_s token, gnode_r *stmts,
 gnode_t *gnode_empty_stat_create (gtoken_s token, gnode_t *decl) {
     gnode_empty_stmt_t *node = (gnode_empty_stmt_t *)mem_alloc(NULL, sizeof(gnode_empty_stmt_t));
 
-    SETBASE(node, NODE_EMPTY_STAT, token, NULL);
+    SETBASE(node, NODE_EMPTY_STAT, token);
     SETDECL(node, decl);
     return (gnode_t *)node;
 }
@@ -161,11 +161,11 @@ gnode_t *gnode_empty_stat_create (gtoken_s token, gnode_t *decl) {
 // MARK: - Declarations initializers -
 
 gnode_t *gnode_class_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_t *superclass,
-                                  gnode_r *protocols, gnode_r *declarations, bool is_struct, void *meta, gnode_t *decl) {
+                                  gnode_r *protocols, gnode_r *declarations, bool is_struct, gnode_t *decl) {
     gnode_class_decl_t *node = (gnode_class_decl_t *)mem_alloc(NULL, sizeof(gnode_class_decl_t));
     node->is_struct = is_struct;
 
-    SETBASE(node, NODE_CLASS_DECL, token, meta);
+    SETBASE(node, NODE_CLASS_DECL, token);
     SETDECL(node, decl);
     node->bridge = false;
     node->identifier = identifier;
@@ -180,10 +180,10 @@ gnode_t *gnode_class_decl_create (gtoken_s token, const char *identifier, gtoken
     return (gnode_t *)node;
 }
 
-gnode_t *gnode_module_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations, void *meta, gnode_t *decl) {
+gnode_t *gnode_module_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations,  gnode_t *decl) {
     gnode_module_decl_t *node = (gnode_module_decl_t *)mem_alloc(NULL, sizeof(gnode_module_decl_t));
 
-    SETBASE(node, NODE_MODULE_DECL, token, meta);
+    SETBASE(node, NODE_MODULE_DECL, token);
     SETDECL(node, decl);
     node->identifier = identifier;
     node->access = access_specifier;
@@ -193,10 +193,10 @@ gnode_t *gnode_module_decl_create (gtoken_s token, const char *identifier, gtoke
     return (gnode_t *)node;
 }
 
-gnode_t *gnode_enum_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, symboltable_t *symtable, void *meta, gnode_t *decl) {
+gnode_t *gnode_enum_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, symboltable_t *symtable, gnode_t *decl) {
     gnode_enum_decl_t *node = (gnode_enum_decl_t *)mem_alloc(NULL, sizeof(gnode_enum_decl_t));
 
-    SETBASE(node, NODE_ENUM_DECL, token, meta);
+    SETBASE(node, NODE_ENUM_DECL, token);
     SETDECL(node, decl);
     node->identifier = identifier;
     node->access = access_specifier;
@@ -207,10 +207,10 @@ gnode_t *gnode_enum_decl_create (gtoken_s token, const char *identifier, gtoken_
 }
 
 gnode_t *gnode_function_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *params,
-                                     gnode_compound_stmt_t *block, void *meta, gnode_t *decl) {
+                                     gnode_compound_stmt_t *block, gnode_t *decl) {
     gnode_function_decl_t *node = (gnode_function_decl_t *)mem_alloc(NULL, sizeof(gnode_function_decl_t));
 
-    SETBASE(node, NODE_FUNCTION_DECL, token, meta);
+    SETBASE(node, NODE_FUNCTION_DECL, token);
     SETDECL(node, decl);
     node->identifier = identifier;
     node->access = access_specifier;
@@ -223,11 +223,10 @@ gnode_t *gnode_function_decl_create (gtoken_s token, const char *identifier, gto
     return (gnode_t *)node;
 }
 
-gnode_t *gnode_variable_decl_create (gtoken_s token, gtoken_t type, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations,
-                                     void *meta, gnode_t *decl) {
+gnode_t *gnode_variable_decl_create (gtoken_s token, gtoken_t type, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations, gnode_t *decl) {
     gnode_variable_decl_t *node = (gnode_variable_decl_t *)mem_alloc(NULL, sizeof(gnode_variable_decl_t));
 
-    SETBASE(node, NODE_VARIABLE_DECL, token, meta);
+    SETBASE(node, NODE_VARIABLE_DECL, token);
     SETDECL(node, decl);
     node->type = type;
     node->access = access_specifier;
@@ -240,7 +239,7 @@ gnode_t *gnode_variable_decl_create (gtoken_s token, gtoken_t type, gtoken_t acc
 gnode_t *gnode_variable_create (gtoken_s token, const char *identifier, const char *annotation_type, gtoken_t access_specifier, gnode_t *expr, gnode_t *decl) {
     gnode_var_t *node = (gnode_var_t *)mem_alloc(NULL, sizeof(gnode_var_t));
 
-    SETBASE(node, NODE_VARIABLE, token, NULL);
+    SETBASE(node, NODE_VARIABLE, token);
     SETDECL(node, decl);
     node->identifier = identifier;
     node->annotation_type = annotation_type;
@@ -303,7 +302,7 @@ gnode_t *gnode_binary_expr_create (gtoken_t op, gnode_t *left, gnode_t *right, g
     if (!left || !right) return NULL;
 
     gnode_binary_expr_t    *node = (gnode_binary_expr_t *)mem_alloc(NULL, sizeof(gnode_binary_expr_t));
-    SETBASE(node, NODE_BINARY_EXPR, left->token, NULL);
+    SETBASE(node, NODE_BINARY_EXPR, left->token);
     SETDECL(node, decl);
     node->op = op;
     node->left = left;
@@ -315,7 +314,7 @@ gnode_t *gnode_unary_expr_create (gtoken_t op, gnode_t *expr, gnode_t *decl) {
     if (!expr) return NULL;
 
     gnode_unary_expr_t *node = (gnode_unary_expr_t *)mem_alloc(NULL, sizeof(gnode_unary_expr_t));
-    SETBASE(node, NODE_UNARY_EXPR, expr->token, NULL);
+    SETBASE(node, NODE_UNARY_EXPR, expr->token);
     SETDECL(node, decl);
     node->op = op;
     node->expr = expr;
@@ -326,7 +325,7 @@ gnode_t *gnode_file_expr_create (gtoken_s token, cstring_r *list, gnode_t *decl)
     if (!list) return NULL;
 
     gnode_file_expr_t *node = (gnode_file_expr_t *)mem_alloc(NULL, sizeof(gnode_file_expr_t));
-    SETBASE(node, NODE_FILE_EXPR, token, NULL);
+    SETBASE(node, NODE_FILE_EXPR, token);
     SETDECL(node, decl);
     node->identifiers = list;
     return (gnode_t *)node;
@@ -336,7 +335,7 @@ gnode_t *gnode_identifier_expr_create (gtoken_s token, const char *identifier, c
     if (!identifier) return NULL;
 
     gnode_identifier_expr_t *node = (gnode_identifier_expr_t *)mem_alloc(NULL, sizeof(gnode_identifier_expr_t));
-    SETBASE(node, NODE_IDENTIFIER_EXPR, token, NULL);
+    SETBASE(node, NODE_IDENTIFIER_EXPR, token);
     SETDECL(node, decl);
     node->value = identifier;
     node->value2 = identifier2;
@@ -357,7 +356,7 @@ void gnode_literal_dump (gnode_literal_expr_t *node, char *buffer, int buffersiz
 static gnode_t *gnode_literal_value_expr_create (gtoken_s token, gliteral_t type, const char *s, double d, int64_t n64, gnode_t *decl) {
     gnode_literal_expr_t *node = (gnode_literal_expr_t *)mem_alloc(NULL, sizeof(gnode_literal_expr_t));
 
-    SETBASE(node, NODE_LITERAL_EXPR, token, NULL);
+    SETBASE(node, NODE_LITERAL_EXPR, token);
     SETDECL(node, decl);
     node->type = type;
     node->len = 0;
@@ -409,7 +408,7 @@ gnode_t *gnode_literal_bool_expr_create (gtoken_s token, int32_t n, gnode_t *dec
 gnode_t *gnode_keyword_expr_create (gtoken_s token, gnode_t *decl) {
     gnode_keyword_expr_t *node = (gnode_keyword_expr_t *)mem_alloc(NULL, sizeof(gnode_keyword_expr_t));
 
-    SETBASE(node, NODE_KEYWORD_EXPR, token, NULL);
+    SETBASE(node, NODE_KEYWORD_EXPR, token);
     SETDECL(node, decl);
     return (gnode_t *)node;
 }
@@ -417,7 +416,7 @@ gnode_t *gnode_keyword_expr_create (gtoken_s token, gnode_t *decl) {
 gnode_t *gnode_postfix_subexpr_create (gtoken_s token, gnode_n type, gnode_t *expr, gnode_r *list, gnode_t *decl) {
     gnode_postfix_subexpr_t *node = (gnode_postfix_subexpr_t *)mem_alloc(NULL, sizeof(gnode_postfix_subexpr_t));
 
-    SETBASE(node, type, token, NULL);
+    SETBASE(node, type, token);
     SETDECL(node, decl);
     if (type == NODE_CALL_EXPR)
         node->args = list;
@@ -429,7 +428,7 @@ gnode_t *gnode_postfix_subexpr_create (gtoken_s token, gnode_n type, gnode_t *ex
 gnode_t *gnode_postfix_expr_create (gtoken_s token, gnode_t *id, gnode_r *list, gnode_t *decl) {
     gnode_postfix_expr_t *node = (gnode_postfix_expr_t *)mem_alloc(NULL, sizeof(gnode_postfix_expr_t));
 
-    SETBASE(node, NODE_POSTFIX_EXPR, token, NULL);
+    SETBASE(node, NODE_POSTFIX_EXPR, token);
     SETDECL(node, decl);
     node->id = id;
     node->list = list;
@@ -439,7 +438,7 @@ gnode_t *gnode_postfix_expr_create (gtoken_s token, gnode_t *id, gnode_r *list,
 gnode_t *gnode_list_expr_create (gtoken_s token, gnode_r *list1, gnode_r *list2, bool ismap, gnode_t *decl) {
     gnode_list_expr_t *node = (gnode_list_expr_t *)mem_alloc(NULL, sizeof(gnode_list_expr_t));
 
-    SETBASE(node, NODE_LIST_EXPR, token, NULL);
+    SETBASE(node, NODE_LIST_EXPR, token);
     SETDECL(node, decl);
     node->ismap = ismap;
     node->list1 = list1;
@@ -490,14 +489,6 @@ gnode_t *gnode_duplicate (gnode_t *node, bool deep) {
     return node;
 }
 
-void *meta_from_node (gnode_t *node) {
-    while (node) {
-        if (node->meta) return node->meta;
-        node = node->decl;
-    }
-    return NULL;
-}
-
 // MARK: - AST deallocator -
 
 // STATEMENTS
@@ -576,8 +567,6 @@ static void free_function_decl (gvisitor_t *self, gnode_function_decl_t *node) {
         gtype_array_each(node->uplist, {mem_free(val);}, gupvalue_t*);
         gnode_array_free(node->uplist);
     }
-    // free meta ONLY if node is not a getter/setter (for getter/setter meta is set to var)
-    if (node->base.meta && node->storage != TOK_KEY_VAR) gravity_hash_free(node->base.meta);
     mem_free((gnode_t*)node);
 }
 
@@ -587,7 +576,6 @@ static void free_variable_decl (gvisitor_t *self, gnode_variable_decl_t *node) {
         gnode_array_each(node->decls, {free_variable(self, (gnode_var_t *)val);});
         gnode_array_free(node->decls);
     }
-    if (node->base.meta) gravity_hash_free(node->base.meta);
     mem_free((gnode_t*)node);
 }
 
@@ -596,7 +584,6 @@ static void free_enum_decl (gvisitor_t *self, gnode_enum_decl_t *node) {
     CHECK_REFCOUNT(node);
     if (node->identifier) mem_free((void *)node->identifier);
     if (node->symtable) symboltable_free(node->symtable);
-    if (node->base.meta) gravity_hash_free(node->base.meta);
     mem_free((gnode_t*)node);
 }
 
@@ -608,7 +595,6 @@ static void free_class_decl (gvisitor_t *self, gnode_class_decl_t *node) {
         gnode_array_free(node->decls);
     }
     if (node->symtable) symboltable_free(node->symtable);
-    if (node->base.meta) gravity_hash_free(node->base.meta);
     mem_free((gnode_t*)node);
 }
 
@@ -620,7 +606,6 @@ static void free_module_decl (gvisitor_t *self, gnode_module_decl_t *node) {
         gnode_array_free(node->decls);
     }
     if (node->symtable) symboltable_free(node->symtable);
-    if (node->base.meta) gravity_hash_free(node->base.meta);
     mem_free((gnode_t*)node);
 }
 

src/compiler/gravity_ast.h

@@ -48,7 +48,6 @@ typedef struct {
     uint32_t    refcount;                   // reference count to manage duplicated nodes
     gtoken_s    token;                      // token type and location
     bool        is_assignment;              // flag to check if it is an assignment node
-    void        *meta;                      // meta decoration (used only in decl nodes in this version but added here in order to prepare for a more complete solution)
     void        *decl;                      // enclosing declaration node
 } gnode_t;
 
@@ -261,13 +260,13 @@ gnode_t *gnode_loop_stat_create (gtoken_s token, gnode_t *cond, gnode_t *stmt, g
 gnode_t *gnode_block_stat_create (gnode_n type, gtoken_s token, gnode_r *stmts, gnode_t *decl);
 gnode_t *gnode_empty_stat_create (gtoken_s token, gnode_t *decl);
 
-gnode_t *gnode_enum_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, symboltable_t *symtable, void *meta, gnode_t *decl);
-gnode_t *gnode_class_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_t *superclass, gnode_r *protocols, gnode_r *declarations, bool is_struct, void *meta, gnode_t *decl);
-gnode_t *gnode_module_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations, void *meta, gnode_t *decl);
-gnode_t *gnode_variable_decl_create (gtoken_s token, gtoken_t type, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations, void *meta, gnode_t *decl);
+gnode_t *gnode_enum_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, symboltable_t *symtable, gnode_t *decl);
+gnode_t *gnode_class_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_t *superclass, gnode_r *protocols, gnode_r *declarations, bool is_struct, gnode_t *decl);
+gnode_t *gnode_module_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations, gnode_t *decl);
+gnode_t *gnode_variable_decl_create (gtoken_s token, gtoken_t type, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *declarations, gnode_t *decl);
 gnode_t *gnode_variable_create (gtoken_s token, const char *identifier, const char *annotation_type, gtoken_t storage_specifier, gnode_t *expr, gnode_t *decl);
 
-gnode_t *gnode_function_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *params, gnode_compound_stmt_t *block, void *meta, gnode_t *decl);
+gnode_t *gnode_function_decl_create (gtoken_s token, const char *identifier, gtoken_t access_specifier, gtoken_t storage_specifier, gnode_r *params, gnode_compound_stmt_t *block, gnode_t *decl);
 
 gnode_t *gnode_binary_expr_create (gtoken_t op, gnode_t *left, gnode_t *right, gnode_t *decl);
 gnode_t *gnode_unary_expr_create (gtoken_t op, gnode_t *expr, gnode_t *decl);
@@ -300,8 +299,6 @@ bool    gnode_is_literal_string (gnode_t *node);
 void    gnode_literal_dump (gnode_literal_expr_t *node, char *buffer, int buffersize);
 void    gnode_free (gnode_t *node);
 
-void    *meta_from_node (gnode_t *node);
-
 // MARK: -
 
 #define gnode_array_init(r)                 marray_init(*r)

src/compiler/gravity_codegen.c

@@ -82,8 +82,7 @@ static void report_error (gvisitor_t *self, gnode_t *node, const char *format, .
         .lineno = (node) ? node->token.lineno : 0,
         .colno = (node) ? node->token.colno : 0,
         .fileid = (node) ? node->token.fileid : 0,
-        .offset = (node) ? node->token.position : 0,
-        .meta = meta_from_node(node)
+        .offset = (node) ? node->token.position : 0
     };
 
     // finally call error callback

src/compiler/gravity_parser.c

@@ -25,7 +25,6 @@ struct gravity_parser_t {
     gnode_r                             *declarations;      // used to keep track of nodes hierarchy
     gnode_r                             *statements;        // used to build AST
     gravity_delegate_t                  *delegate;          // compiler delegate
-    gravity_hash_t                      *meta;              // current node meta (if any)
     uint16_r                            vdecl;              // to keep track of func expression in variable declaration nondes
 
     double                              time;
@@ -138,17 +137,6 @@ static gnode_t *get_enclosing (gravity_parser_t *parser, gnode_n tag) {
     return NULL;
 }
 
-static void parser_setmeta (gravity_parser_t *parser, gravity_hash_t *htable, bool free_old) {
-    if (free_old && parser->meta) gravity_hash_free(parser->meta);
-    parser->meta = htable;
-}
-
-static gravity_hash_t *parser_getmeta (gravity_parser_t *parser, bool consume) {
-    gravity_hash_t *htable = parser->meta;
-    if (consume) parser->meta = NULL;
-    return htable;
-}
-
 static void patch_token_node (gnode_t *node, gtoken_s token) {
     node->token = token;
     
@@ -165,7 +153,7 @@ static void patch_token_node (gnode_t *node, gtoken_s token) {
 }
 
 static void report_error (gravity_parser_t *parser, error_type_t error_type, gtoken_s token, const char *format, ...) {
-    // consider just one error for each line;
+    // just one error for each line
     if (parser->last_error_lineno == token.lineno) return;
     parser->last_error_lineno = token.lineno;
 
@@ -185,19 +173,12 @@ static void report_error (gravity_parser_t *parser, error_type_t error_type, gto
         va_end (arg);
     }
 
-    void *meta = parser_getmeta(parser, false);
-    if (!meta) {
-        gnode_t *node = LAST_DECLARATION();
-        if (node) meta = meta_from_node(node);
-    }
-
     // setup error struct
     error_desc_t error_desc = {
         .lineno = token.lineno,
         .colno = token.colno,
         .fileid = token.fileid,
-        .offset = token.position,
-        .meta = meta
+        .offset = token.position
     };
 
     // finally call error callback
@@ -278,9 +259,6 @@ static bool parse_semicolon (gravity_parser_t *parser) {
 gnode_t *parse_function (gravity_parser_t *parser, bool is_declaration, gtoken_t access_specifier, gtoken_t storage_specifier) {
     DECLARE_LEXER;
 
-    // consume optional meta
-    gravity_hash_t *meta = (is_declaration) ? parser_getmeta(parser, true): NULL;
-
     // access_specifier? storage_specifier? already parsed
     // 'function' IDENTIFIER '(' parameter_declaration_clause? ')' compound_statement
 
@@ -305,7 +283,7 @@ gnode_t *parse_function (gravity_parser_t *parser, bool is_declaration, gtoken_t
     }
 
     // create func declaration node
-    gnode_function_decl_t *func = (gnode_function_decl_t *) gnode_function_decl_create(token, identifier, access_specifier, storage_specifier, NULL, NULL, meta,LAST_DECLARATION());
+    gnode_function_decl_t *func = (gnode_function_decl_t *) gnode_function_decl_create(token, identifier, access_specifier, storage_specifier, NULL, NULL, LAST_DECLARATION());
 
     // check and consume TOK_OP_OPEN_PARENTHESIS
     if (!is_implicit) parse_required(parser, TOK_OP_OPEN_PARENTHESIS);
@@ -351,7 +329,7 @@ static gnode_t *local_store_declaration (gravity_parser_t *parser, const char *i
     gnode_r *decls = gnode_array_create();
     gnode_t *decl = gnode_variable_create(declaration->token, identifier ? string_dup(identifier) : NULL, NULL, access_specifier, declaration, LAST_DECLARATION());
     gnode_array_push(decls, decl);
-    return gnode_variable_decl_create(declaration->token, TOK_KEY_VAR, access_specifier, storage_specifier, decls, NULL, LAST_DECLARATION());
+    return gnode_variable_decl_create(declaration->token, TOK_KEY_VAR, access_specifier, storage_specifier, decls, LAST_DECLARATION());
 }
 
 static gnode_t *decl_check_access_specifier (gnode_t *node) {
@@ -1253,7 +1231,7 @@ static void init_grammer_rules (void) {
 
 // MARK: - Declarations -
 
-static gnode_t *parse_getter_setter (gravity_parser_t *parser, gravity_hash_t *meta) {
+static gnode_t *parse_getter_setter (gravity_parser_t *parser) {
     DEBUG_PARSER("parse_getter_setter");
     DECLARE_LEXER;
 
@@ -1267,7 +1245,7 @@ static gnode_t *parse_getter_setter (gravity_parser_t *parser, gravity_hash_t *m
 
         bool        is_getter = false;
         gtoken_s    token = gravity_lexer_token(lexer);
-        gnode_r        *params = NULL;
+        gnode_r     *params = NULL;
 
         // getter case: does not have explicit parameters (only implicit self)
         if (strcmp(identifier, GETTER_FUNCTION_NAME) == 0) {
@@ -1293,7 +1271,7 @@ static gnode_t *parse_getter_setter (gravity_parser_t *parser, gravity_hash_t *m
         mem_free(identifier);
 
         // create getter/setter func declaration
-        gnode_t *f = gnode_function_decl_create(token, NULL, 0, 0, params, NULL, meta, LAST_DECLARATION());
+        gnode_t *f = gnode_function_decl_create(token, NULL, 0, 0, params, NULL, LAST_DECLARATION());
         // set storage to var so I can identify f as a special getter/setter function
         ((gnode_function_decl_t *)f)->storage = TOK_KEY_VAR;
 
@@ -1347,11 +1325,8 @@ static gnode_t *parse_variable_declaration (gravity_parser_t *parser, bool issta
     }
     token = gravity_lexer_token(lexer);
 
-    // consume optional meta
-    gravity_hash_t *meta = parser_getmeta(parser, true);
-
     // create node variable declaration
-    gnode_variable_decl_t *node = (gnode_variable_decl_t *) gnode_variable_decl_create(token, type, access_specifier, storage_specifier, NULL, meta, LAST_DECLARATION());
+    gnode_variable_decl_t *node = (gnode_variable_decl_t *) gnode_variable_decl_create(token, type, access_specifier, storage_specifier, NULL, LAST_DECLARATION());
 
     // initialize node array
     decls = gnode_array_create();
@@ -1379,7 +1354,7 @@ loop:
         marray_pop(parser->vdecl);
     } else if (peek == TOK_OP_OPEN_CURLYBRACE) {
         gravity_lexer_next(lexer); // consume TOK_OP_OPEN_CURLYBRACE
-        expr = parse_getter_setter(parser, meta);
+        expr = parse_getter_setter(parser);
         parse_required(parser, TOK_OP_CLOSED_CURLYBRACE);
         is_computed = true;
     }
@@ -1450,16 +1425,13 @@ static gnode_t *parse_enum_declaration (gravity_parser_t *parser, gtoken_t acces
     // check and consume TOK_OP_OPEN_CURLYBRACE
     parse_required(parser, TOK_OP_OPEN_CURLYBRACE);
 
-    symboltable_t    *symtable = symboltable_create(SYMTABLE_TAG_ENUM);    // enum symbol table (symtable is OK because order is not important inside an enum)
-    int64_t            enum_autoint = 0;                        // autoincrement value (in case of INT enum)
-    uint32_t        enum_counter = 0;                        // enum internal counter (first value (if any) determines enum type)
-    gliteral_t        enum_type = LITERAL_INT;                // enum type (default to int)
-
-    // consume optional annotation
-    gravity_hash_t *meta = parser_getmeta(parser, true);
+    symboltable_t   *symtable = symboltable_create(SYMTABLE_TAG_ENUM);  // enum symbol table (symtable is OK because order is not important inside an enum)
+    int64_t     enum_autoint = 0;           // autoincrement value (in case of INT enum)
+    uint32_t    enum_counter = 0;           // enum internal counter (first value (if any) determines enum type)
+    gliteral_t  enum_type = LITERAL_INT;    // enum type (default to int)
 
     // create enum node
-    gnode_enum_decl_t *node = (gnode_enum_decl_t *)gnode_enum_decl_create(token, identifier, access_specifier, storage_specifier, symtable, meta, LAST_DECLARATION());
+    gnode_enum_decl_t *node = (gnode_enum_decl_t *)gnode_enum_decl_create(token, identifier, access_specifier, storage_specifier, symtable, LAST_DECLARATION());
 
     while (1) {
         // check for empty enum
@@ -1610,10 +1582,6 @@ static gnode_t *parse_module_declaration (gravity_parser_t *parser, gtoken_t acc
     // parse optional curly brace
     bool curly_brace = parse_optional(parser, TOK_OP_OPEN_CURLYBRACE);
 
-    // parse optional meta
-    gravity_hash_t *meta = parser_getmeta(parser, true);
-    #pragma unused(meta)
-
     // create array of declarations nodes
     gnode_r *declarations = gnode_array_create();
 
@@ -1736,9 +1704,6 @@ static gnode_t *parse_class_declaration (gravity_parser_t *parser, gtoken_t acce
     DEBUG_PARSER("parse_class_declaration");
     DECLARE_LEXER;
 
-    // consume optional meta
-    gravity_hash_t *meta = parser_getmeta(parser, true);
-
     // access_specifier? storage_specifier? 'class' IDENTIFIER class_superclass? class_protocols? '{' declaration_statement* '}' ';'
     // class_superclass: (':') id
     // class_protocols: '<' (id) (',' id)* '>'
@@ -1779,12 +1744,12 @@ static gnode_t *parse_class_declaration (gravity_parser_t *parser, gtoken_t acce
         gnode_t *outer_var = gnode_variable_create(NO_TOKEN, string_dup(OUTER_IVAR_NAME), NULL, 0, NULL, LAST_DECLARATION());
         gnode_array_push(decls, outer_var);
 
-        gnode_t *outer_decl = gnode_variable_decl_create(NO_TOKEN, TOK_KEY_VAR, TOK_KEY_PRIVATE, 0, decls, NULL, LAST_DECLARATION());
+        gnode_t *outer_decl = gnode_variable_decl_create(NO_TOKEN, TOK_KEY_VAR, TOK_KEY_PRIVATE, 0, decls, LAST_DECLARATION());
         gnode_array_push(declarations, outer_decl);
     }
 
     // create class declaration node
-    gnode_class_decl_t *node = (gnode_class_decl_t*) gnode_class_decl_create(token, identifier, access_specifier, storage_specifier, super, protocols, NULL, is_struct, meta, LAST_DECLARATION());
+    gnode_class_decl_t *node = (gnode_class_decl_t*) gnode_class_decl_create(token, identifier, access_specifier, storage_specifier, super, protocols, NULL, is_struct, LAST_DECLARATION());
 
     if (storage_specifier != TOK_KEY_EXTERN) {
         PUSH_DECLARATION(node);
@@ -2132,65 +2097,6 @@ loop:
     return NULL;
 }
 
-static gnode_t *parse_meta_macro (gravity_parser_t *parser) {
-    DEBUG_PARSER("parse_meta_macro");
-    DECLARE_LEXER;
-
-    gravity_hash_t *htable = parser_getmeta(parser, false);
-    bool is_local = !htable;
-    if (!htable) htable = gravity_hash_create(0, gravity_value_hash, gravity_value_equals, gravity_hash_keyvaluefree, NULL);
-
-    parse_required(parser, TOK_OP_OPEN_PARENTHESIS);
-    while (gravity_lexer_peek(lexer) != TOK_OP_CLOSED_PARENTHESIS) {
-        const char *id = parse_identifier(parser);
-        if (id == NULL) goto handle_error;
-
-        parse_required(parser, TOK_OP_COLON);
-
-        gnode_literal_expr_t *node_value= (gnode_literal_expr_t *)parse_literal_expression(parser);
-        if (node_value == NULL) goto handle_error;
-
-        gtoken_t peek = gravity_lexer_peek(lexer);
-        if (peek == TOK_EOF) break;
-        if (peek == TOK_OP_COMMA) gravity_lexer_next(lexer);
-
-        gravity_value_t key;
-        gravity_value_t value;
-
-        // convert node key
-        key = VALUE_FROM_OBJECT(gravity_string_new(NULL, (char *)id, (uint32_t)strlen(id), 0));
-
-        // convert node value
-        if (node_value->type == LITERAL_STRING)
-            value = VALUE_FROM_CSTRING(NULL, node_value->value.str);
-        else if (node_value->type == LITERAL_INT)
-            value = VALUE_FROM_INT((gravity_int_t)node_value->value.n64);
-        else if (node_value->type == LITERAL_FLOAT)
-            value = VALUE_FROM_FLOAT((gravity_float_t)node_value->value.d);
-        else // if (node_value->type == LITERAL_BOOL)
-            value = (node_value->value.n64) ? VALUE_FROM_TRUE : VALUE_FROM_FALSE;
-
-        gravity_hash_insert(htable, key, value);
-
-        gnode_free((gnode_t*)node_value);
-    }
-    parse_required(parser, TOK_OP_CLOSED_PARENTHESIS);
-
-    // parse semicolon
-    parse_semicolon(parser);
-
-    // set parser meta
-    is_local = false;
-    parser_setmeta(parser, htable, false);
-
-    return NULL;
-
-handle_error:
-    if (is_local) gravity_hash_free(htable);
-    else parser_setmeta(parser, NULL, true);
-    return NULL;
-}
-
 // MARK: - Statements -
 
 static gnode_t *parse_label_statement (gravity_parser_t *parser) {
@@ -2452,8 +2358,7 @@ static gnode_t *parse_macro_statement (gravity_parser_t *parser) {
         MACRO_UNITEST = 1,
         MACRO_INCLUDE = 2,
         MACRO_PUSH = 3,
-        MACRO_POP = 4,
-        MACRO_META = 5
+        MACRO_POP = 4
     } builtin_macro;
 
     DEBUG_PARSER("parse_macro_statement");
@@ -2483,7 +2388,6 @@ static gnode_t *parse_macro_statement (gravity_parser_t *parser) {
     builtin_macro macro_type = MACRO_UNKNOWN;
     if (string_cmp(macroid, "unittest") == 0) macro_type = MACRO_UNITEST;
     else if (string_cmp(macroid, "include") == 0) macro_type = MACRO_INCLUDE;
-    else if (string_cmp(macroid, "meta") == 0) macro_type = MACRO_META;
     else if (string_cmp(macroid, "push") == 0) macro_type = MACRO_PUSH;
     else if (string_cmp(macroid, "pop") == 0) macro_type = MACRO_POP;
     mem_free(macroid);
@@ -2501,10 +2405,6 @@ static gnode_t *parse_macro_statement (gravity_parser_t *parser) {
             return parse_include_macro(parser);
             break;
 
-        case MACRO_META:
-            return parse_meta_macro(parser);
-            break;
-
         case MACRO_PUSH:
             break;
 
@@ -2594,7 +2494,7 @@ static void parser_register_core_classes (gravity_parser_t *parser) {
     }
 
     // register a variable declaration node in global statements
-    gnode_t *node = gnode_variable_decl_create(NO_TOKEN, TOK_KEY_VAR, 0, TOK_KEY_EXTERN, decls, NULL, LAST_DECLARATION());;
+    gnode_t *node = gnode_variable_decl_create(NO_TOKEN, TOK_KEY_VAR, 0, TOK_KEY_EXTERN, decls, LAST_DECLARATION());;
     gnode_array_push(parser->statements, (gnode_t *)node);
 }
 
@@ -2620,7 +2520,7 @@ static void parser_register_optional_classes (gravity_parser_t *parser) {
     }
     
     // register a variable declaration node in global statements
-    gnode_t *node = gnode_variable_decl_create(NO_TOKEN, TOK_KEY_VAR, 0, TOK_KEY_EXTERN, decls, NULL, LAST_DECLARATION());;
+    gnode_t *node = gnode_variable_decl_create(NO_TOKEN, TOK_KEY_VAR, 0, TOK_KEY_EXTERN, decls, LAST_DECLARATION());;
     gnode_array_push(parser->statements, (gnode_t *)node);
 }
 

src/compiler/gravity_semacheck1.c

@@ -54,8 +54,7 @@ static void report_error (gvisitor_t *self, gnode_t *node, const char *format, .
         .lineno = node->token.lineno,
         .colno = node->token.colno,
         .fileid = node->token.fileid,
-        .offset = node->token.position,
-        .meta = meta_from_node(node)
+        .offset = node->token.position
     };
 
     // finally call error callback

src/compiler/gravity_semacheck2.c

@@ -75,8 +75,7 @@ static void report_error (gvisitor_t *self, error_type_t error_type, gnode_t *no
         .lineno = node->token.lineno,
         .colno = node->token.colno,
         .fileid = node->token.fileid,
-        .offset = node->token.position,
-        .meta = meta_from_node(node)
+        .offset = node->token.position
     };
 
     // finally call error callback

src/runtime/gravity_vm.c

@@ -153,7 +153,7 @@ static void report_runtime_error (gravity_vm *vm, error_type_t error_type, const
     gravity_error_callback error_cb = ((gravity_delegate_t *)vm->delegate)->error_callback;
     if (error_cb) {
         uint32_t lineno = gravity_vm_lineno(vm);
-        error_desc_t edesc = (error_desc_t){lineno, 0, 0, 0, NULL};
+        error_desc_t edesc = (error_desc_t){lineno, 0, 0, 0};
         void *data = ((gravity_delegate_t *)vm->delegate)->xdata;
 		error_cb(vm, error_type, buffer, edesc, data);
     } else {

src/shared/gravity_delegate.h

@@ -27,7 +27,6 @@ typedef struct {
     uint32_t        colno;
     uint32_t        fileid;
     uint32_t        offset;
-    void            *meta;
 } error_desc_t;
 
 #define ERROR_DESC_NONE     (error_desc_t){0,0,0,0,NULL}