Always fully qualify types for RBIs and avoid using attributes

rbi/prism_static.rbi

@@ -1,196 +1,192 @@
-# typed: true
+class Prism::ParseResult
+  sig { returns(Prism::ProgramNode) }
+  def value; end
 
-module Prism
-  class ParseResult
-    sig { returns(ProgramNode) }
-    def value; end
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
 
-    sig { returns(T::Array[Comment]) }
-    def comments; end
+  sig { returns(T::Array[Prism::ParseError]) }
+  def errors; end
 
-    sig { returns(T::Array[ParseError]) }
-    def errors; end
+  sig { returns(T::Array[Prism::ParseWarning]) }
+  def warnings; end
 
-    sig { returns(T::Array[ParseWarning]) }
-    def warnings; end
-
-    sig { returns(Source) }
-    def source; end
-  end
+  sig { returns(Prism::Source) }
+  def source; end
+end
 
-  class ParseError
-    sig { returns(String) }
-    def message; end
+class Prism::ParseError
+  sig { returns(String) }
+  def message; end
 
-    sig { returns(Location) }
-    def location; end
-  end
+  sig { returns(Prism::Location) }
+  def location; end
+end
 
-  class ParseWarning
-    sig { returns(String) }
-    def message; end
+class Prism::ParseWarning
+  sig { returns(String) }
+  def message; end
 
-    sig { returns(Location) }
-    def location; end
-  end
+  sig { returns(Prism::Location) }
+  def location; end
+end
 
-  class Node
-    sig { returns(T::Array[T.nilable(Node)]) }
-    def child_nodes; end
+class Prism::Node
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
 
-    sig { returns(Location) }
-    def location; end
+  sig { returns(Prism::Location) }
+  def location; end
 
-    sig { returns(String) }
-    def slice; end
-  end
+  sig { returns(String) }
+  def slice; end
+end
 
-  class Comment
-    sig { returns(Location) }
-    def location; end
+class Prism::Comment
+  sig { returns(Prism::Location) }
+  def location; end
 
-    sig { returns(T::Boolean) }
-    def trailing?; end
-  end
+  sig { returns(T::Boolean) }
+  def trailing?; end
+end
 
-  class InlineComment < Comment
-    sig { override.returns(T::Boolean) }
-    def trailing?; end
-  end
+class Prism::InlineComment < Prism::Comment
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
 
-  class EmbDocComment < Comment
-  end
+class Prism::EmbDocComment < Prism::Comment
+end
 
-  class DATAComment < Comment
-  end
+class Prism::DATAComment < Prism::Comment
+end
 
-  class Location
-    sig { params(source: Source, start_offset: Integer, length: Integer).void }
-    def initialize(source, start_offset, length); end
+class Prism::Location
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
+  def initialize(source, start_offset, length); end
 
-    sig { returns(String) }
-    def slice; end
+  sig { returns(String) }
+  def slice; end
 
-    sig { returns(T::Array[Comment]) }
-    def comments; end
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
 
-    sig { params(options: T.untyped).returns(Location) }
-    def copy(**options); end
+  sig { params(options: T.untyped).returns(Prism::Location) }
+  def copy(**options); end
 
-    sig { returns(Integer) }
-    def start_offset; end
+  sig { returns(Integer) }
+  def start_offset; end
 
-    sig { returns(Integer) }
-    def end_offset; end
+  sig { returns(Integer) }
+  def end_offset; end
 
-    sig { returns(Integer) }
-    def start_line; end
+  sig { returns(Integer) }
+  def start_line; end
 
-    sig { returns(Integer) }
-    def end_line; end
+  sig { returns(Integer) }
+  def end_line; end
 
-    sig { returns(Integer) }
-    def start_column; end
+  sig { returns(Integer) }
+  def start_column; end
 
-    sig { returns(Integer) }
-    def end_column; end
-  end
+  sig { returns(Integer) }
+  def end_column; end
+end
 
-  class Source
-    sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
-    def initialize(source, start_line, offsets); end
+class Prism::Source
+  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
+  def initialize(source, start_line, offsets); end
 
-    sig { params(offset: Integer, length: Integer).returns(String) }
-    def slice(offset, length); end
+  sig { params(offset: Integer, length: Integer).returns(String) }
+  def slice(offset, length); end
 
-    sig { params(value: Integer).returns(Integer) }
-    def line(value); end
+  sig { params(value: Integer).returns(Integer) }
+  def line(value); end
 
-    sig { params(value: Integer).returns(Integer) }
-    def line_offset(value); end
+  sig { params(value: Integer).returns(Integer) }
+  def line_offset(value); end
 
-    sig { params(value: Integer).returns(Integer) }
-    def column(value); end
+  sig { params(value: Integer).returns(Integer) }
+  def column(value); end
 
-    sig { returns(String) }
-    def source; end
+  sig { returns(String) }
+  def source; end
 
-    sig { returns(T::Array[Integer]) }
-    def offsets; end
-  end
+  sig { returns(T::Array[Integer]) }
+  def offsets; end
+end
 
-  class Token
-    sig { params(type: T.untyped, value: String, location: Location).void }
-    def initialize(type, value, location); end
+class Prism::Token
+  sig { params(type: T.untyped, value: String, location: Prism::Location).void }
+  def initialize(type, value, location); end
 
-    sig { params(keys: T.untyped).returns(T.untyped) }
-    def deconstruct_keys(keys); end
+  sig { params(keys: T.untyped).returns(T.untyped) }
+  def deconstruct_keys(keys); end
 
-    sig { params(q: T.untyped).returns(T.untyped) }
-    def pretty_print(q); end
+  sig { params(q: T.untyped).returns(T.untyped) }
+  def pretty_print(q); end
 
-    sig { params(other: T.untyped).returns(T::Boolean) }
-    def ==(other); end
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
 
-    sig { returns(T.untyped) }
-    def type; end
+  sig { returns(T.untyped) }
+  def type; end
 
-    sig { returns(String) }
-    def value; end
+  sig { returns(String) }
+  def value; end
 
-    sig { returns(Location) }
-    def location; end
-  end
+  sig { returns(Prism::Location) }
+  def location; end
+end
 
-  class NodeInspector
-    sig { params(prefix: String).void }
-    def initialize(prefix); end
+class Prism::NodeInspector
+  sig { params(prefix: String).void }
+  def initialize(prefix); end
 
-    sig { returns(String) }
-    def prefix; end
+  sig { returns(String) }
+  def prefix; end
 
-    sig { returns(String) }
-    def output; end
+  sig { returns(String) }
+  def output; end
 
-    # Appends a line to the output with the current prefix.
-    sig { params(line: String).void }
-    def <<(line); end
+  # Appends a line to the output with the current prefix.
+  sig { params(line: String).void }
+  def <<(line); end
 
-    # This generates a string that is used as the header of the inspect output
-    # for any given node.
-    sig { params(node: Node).returns(String) }
-    def header(node); end
+  # This generates a string that is used as the header of the inspect output
+  # for any given node.
+  sig { params(node: Prism::Node).returns(String) }
+  def header(node); end
 
-    # Generates a string that represents a list of nodes. It handles properly
-    # using the box drawing characters to make the output look nice.
-    sig { params(prefix: String, nodes: T::Array[Node]).returns(String) }
-    def list(prefix, nodes); end
+  # Generates a string that represents a list of nodes. It handles properly
+  # using the box drawing characters to make the output look nice.
+  sig { params(prefix: String, nodes: T::Array[Prism::Node]).returns(String) }
+  def list(prefix, nodes); end
 
-    # Generates a string that represents a location field on a node.
-    sig { params(value: Location).returns(String) }
-    def location(value); end
+  # Generates a string that represents a location field on a node.
+  sig { params(value: Prism::Location).returns(String) }
+  def location(value); end
 
-    # Generates a string that represents a child node.
-    sig { params(node: Node, append: String).returns(String) }
-    def child_node(node, append); end
+  # Generates a string that represents a child node.
+  sig { params(node: Prism::Node, append: String).returns(String) }
+  def child_node(node, append); end
 
-    # Returns a new inspector that can be used to inspect a child node.
-    sig { params(append: String).returns(NodeInspector) }
-    def child_inspector(append); end
+  # Returns a new inspector that can be used to inspect a child node.
+  sig { params(append: String).returns(Prism::NodeInspector) }
+  def child_inspector(append); end
 
-    # Returns the output as a string.
-    sig { returns(String) }
-    def to_str; end
-  end
+  # Returns the output as a string.
+  sig { returns(String) }
+  def to_str; end
+end
 
-  class BasicVisitor
-    sig { params(node: T.nilable(Node)).void }
-    def visit(node); end
+class Prism::BasicVisitor
+  sig { params(node: T.nilable(Prism::Node)).void }
+  def visit(node); end
 
-    sig { params(nodes: T::Array[T.nilable(Node)]).void }
-    def visit_all(nodes); end
+  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
+  def visit_all(nodes); end
 
-    sig { params(node: Node).void }
-    def visit_child_nodes(node); end
-  end
+  sig { params(node: Prism::Node).void }
+  def visit_child_nodes(node); end
 end