begin work on stag

1 files changed, 463 insertions, 0 deletions

diff --git a/stag/src/scopes.scm b/stag/src/scopes.scm
new file mode 100644
index 0000000..8a5c385
--- /dev/null
+++ b/stag/src/scopes.scm
@@ -0,0 +1,463 @@
+;; see tree-sitter-rust/src/grammar.json for an exhaustive list of productions
+
+;; scopes
+(block) @local.scope              ; { ... }
+(function_item) @local.scope
+(declaration_list) @local.scope   ; mod { ... }
+
+;; impl items can define types and lifetimes:
+;;
+;;    impl<'a, T> Trait for Struct { .. }
+;;
+;; in order to constrain those to the impl block,
+;; we add a local scope here:
+(impl_item) @local.scope
+(struct_item) @local.scope
+(enum_item) @local.scope
+(union_item) @local.scope
+(type_item) @local.scope
+(trait_item) @local.scope
+
+;; let expressions create scopes
+(if_expression
+  [(let_condition)
+   (let_chain)]) @local.scope
+
+;; each match arm can bind variables with
+;; patterns, without creating a block scope;
+;;
+;;     match _ {
+;;        (a, b) => a,
+;;     }
+;;
+;; The bindings for a, b are constrained to
+;; the match arm.
+(match_arm) @local.scope
+
+;; loop labels are defs that are available only
+;; within the scope they create:
+;;
+;;     'outer: loop {
+;;         let x = 2;
+;;     };
+;;     let y = 2;
+;; 
+;; Produces a scope graph like so:
+;;
+;; { 
+;;   defs: [ y ],
+;;   scopes: [
+;;     {
+;;       defs: [ 'outer ],
+;;       scopes: [
+;;         {
+;;           defs: [ x ]
+;;         }
+;;       ]
+;;     }
+;;   ]
+;; }
+;;
+(loop_expression) @local.scope
+(for_expression) @local.scope
+(while_expression) @local.scope
+
+
+;; defs
+
+;; let x = ...;
+(let_declaration 
+  pattern: (identifier) @local.definition.variable)
+
+;; if let x = ...;
+;; while let x = ...;
+(let_condition
+  .
+  (identifier) @local.definition.variable)
+
+;; let (a, b, ...) = ..;
+;; if let (a, b, ...) = {}
+;; while let (a, b, ...) = {}
+;; match _ { (a, b) => { .. } }
+(tuple_pattern (identifier) @local.definition.variable)
+
+;; Some(a)
+(tuple_struct_pattern
+  type: (_)
+  (identifier) @local.definition.variable)
+
+;; let S { field: a } = ..;
+(struct_pattern 
+  (field_pattern 
+    (identifier) @local.definition.variable))
+
+;; let S { a, b } = ..;
+(struct_pattern 
+  (field_pattern 
+    (shorthand_field_identifier) @local.definition.variable))
+
+;; (mut x: T)
+(mut_pattern (identifier) @local.definition.variable)
+
+;; (ref x: T)
+(ref_pattern (identifier) @local.definition.variable)
+
+;; const x = ...;
+(const_item (identifier) @local.definition.const)
+
+;; static x = ...;
+(static_item (identifier) @local.definition.const)
+
+;; fn _(x: _)
+(parameters 
+  (parameter 
+    pattern: (identifier) @local.definition.variable))
+;; fn _(self)
+(parameters 
+  (self_parameter
+    (self) @local.definition.variable))
+
+;; type parameters
+(type_parameters
+  (type_identifier) @local.definition.typedef)
+(type_parameters
+  (lifetime) @local.definition.lifetime)
+(constrained_type_parameter
+  left: (type_identifier) @local.definition.typedef)
+
+;; |x| { ... }
+;; no type
+(closure_parameters (identifier) @local.definition.variable)
+
+;; |x: T| { ... }
+;; with type
+(closure_parameters
+  (parameter
+    (identifier) @local.definition.variable))
+
+;;fn x(..)
+(function_item (identifier) @hoist.definition.function)
+
+;; 'outer: loop { .. }
+(loop_expression
+  (loop_label) @local.definition.label)
+
+;; `for` exprs create two defs: a label (if any) and the
+;; loop variable 
+(for_expression . (identifier) @local.definition.variable)
+(for_expression (loop_label) @local.definition.label)
+
+;; 'label: while cond { .. }
+(while_expression
+  (loop_label) @local.definition.label)
+
+;; type definitions
+(struct_item (type_identifier) @hoist.definition.struct)
+(enum_item (type_identifier) @hoist.definition.enum)
+(union_item (type_identifier) @hoist.definition.union)
+(type_item . (type_identifier) @hoist.definition.typedef)
+(trait_item (type_identifier) @hoist.definition.interface)
+
+;; struct and union fields
+(field_declaration_list
+  (field_declaration 
+    (field_identifier) @local.definition.field))
+
+;; enum variants
+(enum_variant_list
+  (enum_variant 
+    (identifier) @local.definition.enumerator))
+
+;; mod x;
+(mod_item (identifier) @local.definition.module)
+
+;; use statements
+
+;; use item;
+(use_declaration
+  (identifier) @local.import)
+
+;; use path as item;
+(use_as_clause
+  alias: (identifier) @local.import)
+
+;; use path::item;
+(use_declaration 
+  (scoped_identifier 
+    name: (identifier) @local.import))
+
+;; use module::{member1, member2, member3};
+(use_list
+  (identifier) @local.import)
+(use_list 
+  (scoped_identifier
+    name: (identifier) @local.import))
+
+
+;; refs
+
+;; !x
+(unary_expression (identifier) @local.reference)
+
+;; &x
+(reference_expression (identifier) @local.reference)
+
+;; (x)
+(parenthesized_expression (identifier) @local.reference)
+
+;; x?
+(try_expression (identifier) @local.reference)
+
+;; a = b
+(assignment_expression (identifier) @local.reference)
+
+;; a op b
+(binary_expression (identifier) @local.reference)
+
+;; a op= b
+(compound_assignment_expr (identifier) @local.reference)
+
+;; a as b
+(type_cast_expression (identifier) @local.reference)
+
+;; a()
+(call_expression (identifier) @local.reference)
+
+;; Self::foo()
+;;
+;; `foo` can be resolved
+(call_expression
+  (scoped_identifier
+    (identifier) @_self_type
+    (identifier) @local.reference)
+  (#match? @_self_type "Self"))
+
+;; self.foo() 
+;;
+;; `foo` can be resolved
+(call_expression 
+  (field_expression
+    (self)
+    (field_identifier) @local.reference))
+
+;; return a
+(return_expression (identifier) @local.reference)
+
+;; break a
+(break_expression (identifier) @local.reference)
+
+;; break 'label
+(break_expression (loop_label) @local.reference)
+
+;; continue 'label;
+(continue_expression (loop_label) @local.reference)
+
+;; yield x;
+(yield_expression (identifier) @local.reference)
+
+;; await a
+(await_expression (identifier) @local.reference)
+
+;; (a, b)
+(tuple_expression (identifier) @local.reference)
+
+;; a[]
+(index_expression (identifier) @local.reference)
+
+;; ident;
+(expression_statement (identifier) @local.reference)
+
+;; a..b
+(range_expression (identifier) @local.reference)
+
+;; [ident; N]
+(array_expression (identifier) @local.reference)
+
+;; path::to::item
+;;
+;; `path` is a ref
+(scoped_identifier 
+  path: (identifier) @local.reference)
+
+;; rhs of let decls
+(let_declaration 
+  value: (identifier) @local.reference)
+
+;; type T = [T; N]
+;;
+;; N is a ident ref
+(array_type
+  length: (identifier) @local.reference)
+
+;; S { _ }
+(struct_expression
+  (type_identifier) @local.reference)
+
+;; S { a }
+(struct_expression
+  (field_initializer_list
+    (shorthand_field_initializer
+      (identifier) @local.reference)))
+
+;; S { a: value }
+(struct_expression
+  (field_initializer_list
+    (field_initializer 
+      (identifier) @local.reference)))
+
+;; S { ..a }
+(struct_expression
+  (field_initializer_list
+    (base_field_initializer 
+      (identifier) @local.reference)))
+
+;; if a {}
+(if_expression (identifier) @local.reference)
+
+;; for pattern in value {}
+;;
+;; `value` is a ref
+(for_expression
+  value: (identifier) @local.reference)
+
+;; while a {}
+(while_expression (identifier) @local.reference)
+
+;; if let _ = a {}
+;;
+;; the ident following the `=` is a ref
+;; the ident preceding the `=` is a def
+;; while let _ = a {}
+(let_condition 
+  "="
+  (identifier) @local.reference)
+
+
+;; match a
+(match_expression (identifier) @local.reference)
+
+;; match _ {
+;;     pattern => a,
+;; }
+;;
+;; this `a` is somehow not any expression form
+(match_arm (identifier) @local.reference)
+
+;; a.b
+;;
+;; `b` is ignored
+(field_expression
+  (identifier) @local.reference)
+
+;; { stmt; foo }
+(block
+  (identifier) @local.reference)
+
+;; arguments to method calls or function calls
+(arguments
+  (identifier) @local.reference)
+
+;; impl S { .. }
+(impl_item (type_identifier) @local.reference)
+
+;; where T: ...
+(where_predicate
+  left: (type_identifier) @local.reference)
+
+;; trait bounds
+(trait_bounds
+  (type_identifier) @local.reference)
+(trait_bounds
+  (lifetime) @local.reference)
+
+;; idents in macros
+(token_tree
+  (identifier) @local.reference)
+
+;; types
+
+;; (T, U)
+(tuple_type
+  (type_identifier) @local.reference)
+
+;; &T
+(reference_type
+  (type_identifier) @local.reference)
+
+;; &'a T
+(reference_type
+  (lifetime) @local.reference)
+
+;; &'a self
+(self_parameter 
+  (lifetime) @local.reference)
+
+;; *mut T
+;; *const T
+(pointer_type
+  (type_identifier) @local.reference)
+
+;; A<_>
+(generic_type
+  (type_identifier) @local.reference)
+
+;; _<V>
+(type_arguments
+  (type_identifier) @local.reference)
+(type_arguments
+  (lifetime) @local.reference)
+
+;; T<U = V>
+;;
+;; U is ignored
+;; V is a ref
+(type_binding
+  name: (_)
+  type: (type_identifier) @local.reference)
+
+;; [T]
+(array_type
+  (type_identifier) @local.reference)
+
+;; type T = U;
+;;
+;; T is a def
+;; U is a ref
+(type_item 
+  name: (_)
+  type: (type_identifier) @local.reference)
+
+(function_item 
+  return_type: (type_identifier) @local.reference)
+
+;; type refs in params
+;;
+;; fn _(_: T)
+(parameters 
+  (parameter 
+    type: (type_identifier) @local.reference))
+
+;; dyn T
+(dynamic_type
+  (type_identifier) @local.reference)
+
+;; <T>::call()
+(bracketed_type
+  (type_identifier) @local.reference)
+
+;; T as Trait
+(qualified_type
+  (type_identifier) @local.reference)
+
+;; module::T
+;;
+;; `module` is a def
+;; `T` is a ref
+(scoped_type_identifier
+  path: (identifier) @local.reference)
+
+;; struct _ { field: Type }
+;; `Type` is a ref
+ (field_declaration
+   name: (_)
+   type: (type_identifier) @local.reference)