================================================================================
Dependencies
================================================================================

dep english;

dep english {}

dep english {
    dep greetings {}
    dep farewells {}
}

dep bar/baz;

--------------------------------------------------------------------------------

(source_file
  (dep_item
    (identifier))
  (dep_item
    (identifier)
    (declaration_list))
  (dep_item
    (identifier)
    (declaration_list
      (dep_item
        (identifier)
        (declaration_list))
      (dep_item
        (identifier)
        (declaration_list))))
  (dep_item
    (identifier)
    (identifier)))

================================================================================
Function declarations
================================================================================

fn main() {}

fn add(x: i32, y: i32) -> i32 {
    return x + y;
}

fn foo() -> [u32; 2] {
    return [1, 2];
}

fn foo() -> (u32, u16) {
    return (1, 2);
}

fn foo() {
    return
}

fn foo(x: impl FnOnce() -> result::Result<T, E>) {}

fn foo(#[attr] x: i32, #[attr] x: i64) {}

fn accumulate(self) -> Machine<{State::Accumulate}> {}

--------------------------------------------------------------------------------

(source_file
  (function_item
    name: (identifier)
    parameters: (parameters)
    body: (block))
  (function_item
    name: (identifier)
    parameters: (parameters
      (parameter
        pattern: (identifier)
        type: (primitive_type))
      (parameter
        pattern: (identifier)
        type: (primitive_type)))
    return_type: (primitive_type)
    body: (block
      (expression_statement
        (return_expression
          (binary_expression
            left: (identifier)
            right: (identifier))))))
  (function_item
    name: (identifier)
    parameters: (parameters)
    return_type: (array_type
      element: (primitive_type)
      length: (integer_literal))
    body: (block
      (expression_statement
        (return_expression
          (array_expression
            (integer_literal)
            (integer_literal))))))
  (function_item
    name: (identifier)
    parameters: (parameters)
    return_type: (tuple_type
      (primitive_type)
      (primitive_type))
    body: (block
      (expression_statement
        (return_expression
          (tuple_expression
            (integer_literal)
            (integer_literal))))))
  (function_item
    name: (identifier)
    parameters: (parameters)
    body: (block
      (return_expression)))
  (function_item
    name: (identifier)
    parameters: (parameters
      (parameter
        pattern: (identifier)
        type: (abstract_type
          trait: (function_type
            trait: (type_identifier)
            parameters: (parameters)
            return_type: (generic_type
              type: (scoped_type_identifier
                path: (identifier)
                name: (type_identifier))
              type_arguments: (type_arguments
                (type_identifier)
                (type_identifier)))))))
    body: (block))
  (function_item
    name: (identifier)
    parameters: (parameters
      (attribute_item
        (attribute
          (identifier)))
      (parameter
        pattern: (identifier)
        type: (primitive_type))
      (attribute_item
        (attribute
          (identifier)))
      (parameter
        pattern: (identifier)
        type: (primitive_type)))
    body: (block))
  (function_item
    name: (identifier)
    parameters: (parameters
      (self_parameter
        (self)))
    return_type: (generic_type
      type: (type_identifier)
      type_arguments: (type_arguments
        (block
          (scoped_identifier
            path: (identifier)
            name: (identifier)))))
    body: (block)))

================================================================================
Const function declarations
================================================================================

const fn main() {}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (function_modifiers)
    (identifier)
    (parameters)
    (block)))

================================================================================
Functions with abstract return types
================================================================================

fn triples(a: impl B) -> impl Iterator<Item=(usize)> {
}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (identifier)
    (parameters
      (parameter
        (identifier)
        (abstract_type
          (type_identifier))))
    (abstract_type
      (generic_type
        (type_identifier)
        (type_arguments
          (type_binding
            (type_identifier)
            (tuple_type
              (primitive_type))))))
    (block)))

================================================================================
Use declarations
================================================================================

use abc;
use phrases::japanese;
use sayings::english::greetings;
use sayings::english::greetings as en_greetings ;
use phrases::english::{greetings,farewells};
use sayings::japanese::farewells::*;
pub use self::greetings::hello;
use sayings::english::{self, greetings as en_greetings, farewells as en_farewells};
use three::{ dot::{one, four} };
use my::{ some::* };
use my::{*};

--------------------------------------------------------------------------------

(source_file
  (use_declaration
    argument: (identifier))
  (use_declaration
    argument: (scoped_identifier
      path: (identifier)
      name: (identifier)))
  (use_declaration
    argument: (scoped_identifier
      path: (scoped_identifier
        path: (identifier)
        name: (identifier))
      name: (identifier)))
  (use_declaration
    argument: (use_as_clause
      path: (scoped_identifier
        path: (scoped_identifier
          path: (identifier)
          name: (identifier))
        name: (identifier))
      alias: (identifier)))
  (use_declaration
    argument: (scoped_use_list
      path: (scoped_identifier
        path: (identifier)
        name: (identifier))
      list: (use_list
        (identifier)
        (identifier))))
  (use_declaration
    argument: (use_wildcard
      (scoped_identifier
        path: (scoped_identifier
          path: (identifier)
          name: (identifier))
        name: (identifier))))
  (use_declaration
    (visibility_modifier)
    argument: (scoped_identifier
      path: (scoped_identifier
        path: (self)
        name: (identifier))
      name: (identifier)))
  (use_declaration
    argument: (scoped_use_list
      path: (scoped_identifier
        path: (identifier)
        name: (identifier))
      list: (use_list
        (self)
        (use_as_clause
          path: (identifier)
          alias: (identifier))
        (use_as_clause
          path: (identifier)
          alias: (identifier)))))
  (use_declaration
    argument: (scoped_use_list
      path: (identifier)
      list: (use_list
        (scoped_use_list
          path: (identifier)
          list: (use_list
            (identifier)
            (identifier))))))
  (use_declaration
    argument: (scoped_use_list
      path: (identifier)
      list: (use_list
        (use_wildcard
          (identifier)))))
  (use_declaration
    argument: (scoped_use_list
      path: (identifier)
      list: (use_list
        (use_wildcard)))))

================================================================================
Variable bindings
================================================================================

let x;
let x = 42;
let x: i32;
let x: i8 = 42;
let mut x = 5;
let y: bool = false;
let bool: bool = false;
let u32: str = "";

--------------------------------------------------------------------------------

(source_file
  (let_declaration
    (identifier))
  (let_declaration
    (identifier)
    (integer_literal))
  (let_declaration
    (identifier)
    (primitive_type))
  (let_declaration
    (identifier)
    (primitive_type)
    (integer_literal))
  (let_declaration
    (mutable_specifier)
    (identifier)
    (integer_literal))
  (let_declaration
    (identifier)
    (primitive_type)
    (boolean_literal))
  (let_declaration
    (identifier)
    (primitive_type)
    (boolean_literal))
  (let_declaration
    (identifier)
    (primitive_type)
    (string_literal)))

================================================================================
Let-else Statements
================================================================================

let Foo::Bar {
    texts,
    values,
} = foo().bar()? else {
    return Err(index)
};

let Some(x) = y else {
    let None = z else {
        foo();
        break;
    };
    continue;
};

--------------------------------------------------------------------------------

(source_file
  (let_declaration
    pattern: (struct_pattern
      type: (scoped_type_identifier
        path: (identifier)
        name: (type_identifier))
      (field_pattern
        name: (shorthand_field_identifier))
      (field_pattern
        name: (shorthand_field_identifier)))
    value: (try_expression
      (call_expression
        function: (field_expression
          value: (call_expression
            function: (identifier)
            arguments: (arguments))
          field: (field_identifier))
        arguments: (arguments)))
    alternative: (block
      (return_expression
        (call_expression
          function: (identifier)
          arguments: (arguments
            (identifier))))))
  (let_declaration
    pattern: (tuple_struct_pattern
      type: (identifier)
      (identifier))
    value: (identifier)
    alternative: (block
      (let_declaration
        pattern: (identifier)
        value: (identifier)
        alternative: (block
          (expression_statement
            (call_expression
              function: (identifier)
              arguments: (arguments)))
          (expression_statement
            (break_expression))))
      (expression_statement
        (continue_expression)))))

================================================================================
Let declarations with if expressions as the value
================================================================================

let a = if b {
    c
} else {
    d
};

--------------------------------------------------------------------------------

(source_file
  (let_declaration
    (identifier)
    (if_expression
      (identifier)
      (block
        (identifier))
      (else_clause
        (block
          (identifier))))))

================================================================================
Let declarations with contextual keywords as names
================================================================================

let default = 1;
let union = 2;

--------------------------------------------------------------------------------

(source_file
  (let_declaration
    (identifier)
    (integer_literal))
  (let_declaration
    (identifier)
    (integer_literal)))

================================================================================
Structs
================================================================================

struct Proton;
struct Electron {}
struct Person {pub name: String, pub age: u32}
struct Point {
  x: i32,

  #[attribute1]
  y: i32,
}
struct Color(pub i32, i32, i32);
struct Inches(i32);

--------------------------------------------------------------------------------

(source_file
  (struct_item
    (type_identifier))
  (struct_item
    (type_identifier)
    (field_declaration_list))
  (struct_item
    (type_identifier)
    (field_declaration_list
      (field_declaration
        (visibility_modifier)
        (field_identifier)
        (type_identifier))
      (field_declaration
        (visibility_modifier)
        (field_identifier)
        (primitive_type))))
  (struct_item
    (type_identifier)
    (field_declaration_list
      (field_declaration
        (field_identifier)
        (primitive_type))
      (attribute_item
        (attribute
          (identifier)))
      (field_declaration
        (field_identifier)
        (primitive_type))))
  (struct_item
    (type_identifier)
    (ordered_field_declaration_list
      (visibility_modifier)
      (primitive_type)
      (primitive_type)
      (primitive_type)))
  (struct_item
    (type_identifier)
    (ordered_field_declaration_list
      (primitive_type))))

================================================================================
Generic structs
================================================================================

struct A<B> {}
struct D<const SIZE: usize> {}

--------------------------------------------------------------------------------

(source_file
  (struct_item
    name: (type_identifier)
    type_parameters: (type_parameters
      (type_identifier))
    body: (field_declaration_list))
  (struct_item
    name: (type_identifier)
    type_parameters: (type_parameters
      (const_parameter
        name: (identifier)
        type: (primitive_type)))
    body: (field_declaration_list)))

================================================================================
Enums
================================================================================

pub enum Option<T> {
    None,
    Some: T,
}

pub enum Node<T> {
    Internal: Vec<T>,
    #[attribute1]
    #[attribute2]
    Leaf: T,
}

--------------------------------------------------------------------------------

(source_file
  (enum_item
    (visibility_modifier)
    (type_identifier)
    (type_parameters
      (type_identifier))
    (enum_variant_list
      (enum_variant
        (identifier))
      (enum_variant
        (identifier)
        (type_identifier))))
  (enum_item
    (visibility_modifier)
    (type_identifier)
    (type_parameters
      (type_identifier))
    (enum_variant_list
      (enum_variant
        (identifier)
        (generic_type
          (type_identifier)
          (type_arguments
            (type_identifier))))
      (attribute_item
        (attribute
          (identifier)))
      (attribute_item
        (attribute
          (identifier)))
      (enum_variant
        (identifier)
        (type_identifier)))))

================================================================================
Generic functions
================================================================================

pub fn splice<T: Into<Text>>(&mut self, old_range: Range<usize>, new_text: T) {
}

pub fn uninit_array<const LEN: usize>() -> [Self; LEN] {}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (visibility_modifier)
    name: (identifier)
    type_parameters: (type_parameters
      (constrained_type_parameter
        left: (type_identifier)
        bounds: (trait_bounds
          (generic_type
            type: (type_identifier)
            type_arguments: (type_arguments
              (type_identifier))))))
    parameters: (parameters
      (self_parameter
        (mutable_specifier)
        (self))
      (parameter
        pattern: (identifier)
        type: (generic_type
          type: (type_identifier)
          type_arguments: (type_arguments
            (primitive_type))))
      (parameter
        pattern: (identifier)
        type: (type_identifier)))
    body: (block))
  (function_item
    (visibility_modifier)
    name: (identifier)
    type_parameters: (type_parameters
      (const_parameter
        name: (identifier)
        type: (primitive_type)))
    parameters: (parameters)
    return_type: (array_type
      element: (type_identifier)
      length: (identifier))
    body: (block)))

================================================================================
Functions with mutable parameters
================================================================================

fn foo(mut x : u32) {
}

impl Foo {
    pub fn set(ref mut self, value: u64) {
        self.value = value;
    }
}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (identifier)
    (parameters
      (parameter
        (mutable_specifier)
        (identifier)
        (primitive_type)))
    (block))
  (impl_item
    (type_identifier)
    (declaration_list
      (function_item
        (visibility_modifier)
        (identifier)
        (parameters
          (self_parameter
            (mutable_specifier)
            (self))
          (parameter
            (identifier)
            (primitive_type)))
        (block
          (expression_statement
            (assignment_expression
              (field_expression
                (self)
                (field_identifier))
              (identifier))))))))

================================================================================
Functions with destructured parameters
================================================================================

fn f1([x, y]: [u32; 2]) {}
fn f2(&x: &Y) {}
fn f3((x, y): (T, U)) {}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (identifier)
    (parameters
      (parameter
        (slice_pattern
          (identifier)
          (identifier))
        (array_type
          (primitive_type)
          (integer_literal))))
    (block))
  (function_item
    (identifier)
    (parameters
      (parameter
        (reference_pattern
          (identifier))
        (reference_type
          (type_identifier))))
    (block))
  (function_item
    (identifier)
    (parameters
      (parameter
        (tuple_pattern
          (identifier)
          (identifier))
        (tuple_type
          (type_identifier)
          (type_identifier))))
    (block)))

================================================================================
Functions with custom types for self
================================================================================

trait Callback {
    fn call(self: Box<Self>);
}

--------------------------------------------------------------------------------

(source_file
  (trait_item
    (type_identifier)
    (declaration_list
      (function_signature_item
        (identifier)
        (parameters
          (parameter
            (self)
            (generic_type
              (type_identifier)
              (type_arguments
                (type_identifier)))))))))

================================================================================
Constant items
================================================================================

const N: i32 = 5;

trait Foo {
    const X: u8;
}

const OWNER_ADDRESS = Address::from(0x8900c5bec4ca97d4febf9ceb4754a60d782abbf3cd815836c1872116f203f861);

--------------------------------------------------------------------------------

(source_file
  (const_item
    (identifier)
    (primitive_type)
    (integer_literal))
  (trait_item
    (type_identifier)
    (declaration_list
      (const_item
        (identifier)
        (primitive_type))))
  (const_item
    (identifier)
    (call_expression
      (scoped_identifier
        (identifier)
        (identifier))
      (arguments
        (integer_literal)))))

================================================================================
Empty statements
================================================================================

fn main() {
    ;
}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (identifier)
    (parameters)
    (block
      (empty_statement))))

================================================================================
Attributes
================================================================================

#[test]
fn test_foo() {}

#[derive(Debug)]
struct Baz;

#[derive(Debug, Eq,)]
struct Foo;

#[cfg(target_os = "macos")]
dep macos_only {}

#![allow(clippy::useless_transmute)]

#[clippy::cyclomatic_complexity = "100"]

#[payable, storage(read, write)]
fn receive_funds() {
    // Do something
}

--------------------------------------------------------------------------------

(source_file
  (attribute_item
    (attribute
      (identifier)))
  (function_item
    name: (identifier)
    parameters: (parameters)
    body: (block))
  (attribute_item
    (attribute
      (identifier)
      arguments: (token_tree
        (identifier))))
  (struct_item
    name: (type_identifier))
  (attribute_item
    (attribute
      (identifier)
      arguments: (token_tree
        (identifier)
        (identifier))))
  (struct_item
    name: (type_identifier))
  (attribute_item
    (attribute
      (identifier)
      arguments: (token_tree
        (identifier)
        (string_literal))))
  (dep_item
    name: (identifier)
    body: (declaration_list))
  (inner_attribute_item
    (attribute
      (identifier)
      arguments: (token_tree
        (identifier)
        (identifier))))
  (attribute_item
    (attribute
      (scoped_identifier
        path: (identifier)
        name: (identifier))
      value: (string_literal)))
  (attribute_item
    (attribute
      (identifier))
    (attribute
      (identifier)
      arguments: (token_tree
        (identifier)
        (identifier))))
  (function_item
    name: (identifier)
    parameters: (parameters)
    body: (block
      (line_comment))))

================================================================================
Inner attributes
================================================================================

dep macos_only {
  #![cfg(target_os = "macos")]
}

--------------------------------------------------------------------------------

(source_file
  (dep_item
    name: (identifier)
    body: (declaration_list
      (inner_attribute_item
        (attribute
          (identifier)
          arguments: (token_tree
            (identifier)
            (string_literal)))))))

================================================================================
Key-Value Attribute Expressions
================================================================================

#[namespace = foo::bar]
fn baz() {}

--------------------------------------------------------------------------------

(source_file
  (attribute_item
    (attribute
      (identifier)
      (scoped_identifier
        (identifier)
        (identifier))))
  (function_item
    (identifier)
    (parameters)
    (block)))

================================================================================
Attributes and Expressions
================================================================================

fn foo() {
   bar(x,
       #[cfg(foo = "bar")]
       y);
   let z = [#[hello] 2, 7, 8];
   let t = (#[hello] 2, 7, 8);
}

--------------------------------------------------------------------------------

(source_file
  (function_item
    name: (identifier)
    parameters: (parameters)
    body: (block
      (expression_statement
        (call_expression
          function: (identifier)
          arguments: (arguments
            (identifier)
            (attribute_item
              (attribute
                (identifier)
                arguments: (token_tree
                  (identifier)
                  (string_literal))))
            (identifier))))
      (let_declaration
        pattern: (identifier)
        value: (array_expression
          (attribute_item
            (attribute
              (identifier)))
          (integer_literal)
          (integer_literal)
          (integer_literal)))
      (let_declaration
        pattern: (identifier)
        value: (tuple_expression
          (attribute_item
            (attribute
              (identifier)))
          (integer_literal)
          (integer_literal)
          (integer_literal))))))

================================================================================
Inherent Impls
================================================================================

impl Person {
  const leg_count : u32 = 2;

  fn walk(self) {}
  fn walk_mut(mut self) {}
  fn talk(& self) {}
}

impl Machine<{State::Init}> {}

--------------------------------------------------------------------------------

(source_file
  (impl_item
    type: (type_identifier)
    body: (declaration_list
      (const_item
        name: (identifier)
        type: (primitive_type)
        value: (integer_literal))
      (function_item
        name: (identifier)
        parameters: (parameters
          (self_parameter
            (self)))
        body: (block))
      (function_item
        name: (identifier)
        parameters: (parameters
          (self_parameter
            (mutable_specifier)
            (self)))
        body: (block))
      (function_item
        name: (identifier)
        parameters: (parameters
          (self_parameter
            (self)))
        body: (block))))
  (impl_item
    type: (generic_type
      type: (type_identifier)
      type_arguments: (type_arguments
        (block
          (scoped_identifier
            path: (identifier)
            name: (identifier)))))
    body: (declaration_list)))

================================================================================
Trait impls
================================================================================

impl ConvertTo<i64> for i32 {
    fn convert(&self) -> i64 { *self as i64 }
}

--------------------------------------------------------------------------------

(source_file
  (impl_item
    trait: (generic_type
      type: (type_identifier)
      type_arguments: (type_arguments
        (primitive_type)))
    type: (primitive_type)
    body: (declaration_list
      (function_item
        name: (identifier)
        parameters: (parameters
          (self_parameter
            (self)))
        return_type: (primitive_type)
        body: (block
          (type_cast_expression
            value: (unary_expression
              (self))
            type: (primitive_type)))))))

================================================================================
Trait impl signature
================================================================================

impl<K: Debug + Ord> Debug for OccupiedError<K>;
impl<K: Debug + Ord> Display for OccupiedError<K>;

--------------------------------------------------------------------------------

(source_file
  (impl_item
    (type_parameters
      (constrained_type_parameter
        (type_identifier)
        (trait_bounds
          (type_identifier)
          (type_identifier))))
    (type_identifier)
    (generic_type
      (type_identifier)
      (type_arguments
        (type_identifier))))
  (impl_item
    (type_parameters
      (constrained_type_parameter
        (type_identifier)
        (trait_bounds
          (type_identifier)
          (type_identifier))))
    (type_identifier)
    (generic_type
      (type_identifier)
      (type_arguments
        (type_identifier)))))

================================================================================
Impls with default functions
================================================================================

impl Foo {
  const default fn bar() -> i32 {
    // Make 'default' still works as an identifier
    default.bar();
  }
}

--------------------------------------------------------------------------------

(source_file
  (impl_item
    (type_identifier)
    (declaration_list
      (function_item
        (function_modifiers)
        (identifier)
        (parameters)
        (primitive_type)
        (block
          (line_comment)
          (expression_statement
            (call_expression
              (field_expression
                (identifier)
                (field_identifier))
              (arguments))))))))

================================================================================
Trait declarations
================================================================================

pub trait Item: Clone + Eq + fmt::Debug {
    fn summarize(&self) -> Self::Summary;
}

--------------------------------------------------------------------------------

(source_file
  (trait_item
    (visibility_modifier)
    (type_identifier)
    (trait_bounds
      (type_identifier)
      (type_identifier)
      (scoped_type_identifier
        (identifier)
        (type_identifier)))
    (declaration_list
      (function_signature_item
        (identifier)
        (parameters
          (self_parameter
            (self)))
        (scoped_type_identifier
          (identifier)
          (type_identifier))))))

================================================================================
Trait declarations with optional type parameters
================================================================================

trait Add<RHS=Self> {
    fn add(self, rhs: RHS) -> Self::Output;
}

--------------------------------------------------------------------------------

(source_file
  (trait_item
    (type_identifier)
    (type_parameters
      (optional_type_parameter
        (type_identifier)
        (type_identifier)))
    (declaration_list
      (function_signature_item
        (identifier)
        (parameters
          (self_parameter
            (self))
          (parameter
            (identifier)
            (type_identifier)))
        (scoped_type_identifier
          (identifier)
          (type_identifier))))))

================================================================================
Unsized types in trait bounds
================================================================================

trait Foo<T: ?Sized> {
}

--------------------------------------------------------------------------------

(source_file
  (trait_item
    (type_identifier)
    (type_parameters
      (constrained_type_parameter
        (type_identifier)
        (trait_bounds
          (removed_trait_bound
            (type_identifier)))))
    (declaration_list)))

================================================================================
Visibility modifiers
================================================================================

pub fn a() {}
pub(self) fn c() {}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (visibility_modifier)
    (identifier)
    (parameters)
    (block))
  (function_item
    (visibility_modifier
      (self))
    (identifier)
    (parameters)
    (block)))

================================================================================
Function parameter names that match built-in type names
================================================================================

fn foo(str: *const c_char) {}
fn bar(bool: bool) {}

--------------------------------------------------------------------------------

(source_file
  (function_item
    (identifier)
    (parameters
      (parameter
        (identifier)
        (pointer_type
          (type_identifier))))
    (block))
  (function_item
    (identifier)
    (parameters
      (parameter
        (identifier)
        (primitive_type)))
    (block)))

================================================================================
Where clauses
================================================================================

fn walk<F>(&self, it: &mut F) -> bool
    where F: FnMut(&Pat) -> bool
{
  return false
}

impl<T> A for B<T> where (T, T, T): C, {}

pub trait A<B> where B: C,
{
}

fn foo<A>() where A: B + As<f64>, f64: As<A> {}

impl<A> Default for B<A> where *mut A: C + D {}

--------------------------------------------------------------------------------

(source_file
  (function_item
    name: (identifier)
    type_parameters: (type_parameters
      (type_identifier))
    parameters: (parameters
      (self_parameter
        (self))
      (parameter
        pattern: (identifier)
        type: (reference_type
          (mutable_specifier)
          type: (type_identifier))))
    return_type: (primitive_type)
    (where_clause
      (where_predicate
        left: (type_identifier)
        bounds: (trait_bounds
          (function_type
            trait: (type_identifier)
            parameters: (parameters
              (reference_type
                type: (type_identifier)))
            return_type: (primitive_type)))))
    body: (block
      (return_expression
        (boolean_literal))))
  (impl_item
    type_parameters: (type_parameters
      (type_identifier))
    trait: (type_identifier)
    type: (generic_type
      type: (type_identifier)
      type_arguments: (type_arguments
        (type_identifier)))
    (where_clause
      (where_predicate
        left: (tuple_type
          (type_identifier)
          (type_identifier)
          (type_identifier))
        bounds: (trait_bounds
          (type_identifier))))
    body: (declaration_list))
  (trait_item
    (visibility_modifier)
    name: (type_identifier)
    type_parameters: (type_parameters
      (type_identifier))
    (where_clause
      (where_predicate
        left: (type_identifier)
        bounds: (trait_bounds
          (type_identifier))))
    body: (declaration_list))
  (function_item
    name: (identifier)
    type_parameters: (type_parameters
      (type_identifier))
    parameters: (parameters)
    (where_clause
      (where_predicate
        left: (type_identifier)
        bounds: (trait_bounds
          (type_identifier)
          (generic_type
            type: (type_identifier)
            type_arguments: (type_arguments
              (primitive_type)))))
      (where_predicate
        left: (primitive_type)
        bounds: (trait_bounds
          (generic_type
            type: (type_identifier)
            type_arguments: (type_arguments
              (type_identifier))))))
    body: (block))
  (impl_item
    type_parameters: (type_parameters
      (type_identifier))
    trait: (type_identifier)
    type: (generic_type
      type: (type_identifier)
      type_arguments: (type_arguments
        (type_identifier)))
    (where_clause
      (where_predicate
        left: (pointer_type
          (mutable_specifier)
          type: (type_identifier))
        bounds: (trait_bounds
          (type_identifier)
          (type_identifier))))
    body: (declaration_list)))

================================================================================
Reserved keywords in path
================================================================================

struct A {
  a: default::B,
  b: union::C,
}

--------------------------------------------------------------------------------

(source_file
  (struct_item
    (type_identifier)
    (field_declaration_list
      (field_declaration
        (field_identifier)
        (scoped_type_identifier
          (identifier)
          (type_identifier)))
      (field_declaration
        (field_identifier)
        (scoped_type_identifier
          (identifier)
          (type_identifier))))))