diff --git a/proto/SCIP.proto b/proto/SCIP.proto index 735e60e85..2f867837c 100644 --- a/proto/SCIP.proto +++ b/proto/SCIP.proto @@ -400,6 +400,14 @@ message Occurrence { SyntaxKind syntax_kind = 5; // (optional) Diagnostics that have been reported for this specific range. repeated Diagnostic diagnostics = 6; + // (optional) Using the same encoding as the sibling `range` field, half-open + // source range of the nearest non-trivial enclosing AST node. This range must + // enclose the `range` field. + // + // For definition occurrences, the enclosing range should indicate the + // start/end bounds of the entire definition AST node, including + // documentation. + repeated int32 enclosing_range = 7; } // Represents a diagnostic, such as a compiler error or warning, which should be diff --git a/scip_indexer/SCIPIndexer.cc b/scip_indexer/SCIPIndexer.cc index 3f3e4bbf2..7d746638e 100644 --- a/scip_indexer/SCIPIndexer.cc +++ b/scip_indexer/SCIPIndexer.cc @@ -288,7 +288,8 @@ class SCIPState { absl::Status saveDefinitionImpl(const core::GlobalState &gs, core::FileRef file, const string &symbolString, core::Loc occLoc, const SmallVec &docs, - const SmallVec &rels) { + const SmallVec &rels, + optional enclosingLoc = nullopt) { ENFORCE(!symbolString.empty()); occLoc = trimColonColonPrefix(gs, occLoc); auto range = sorbet::scip_indexer::fromSorbetLoc(gs, occLoc); @@ -305,6 +306,12 @@ class SCIPState { for (auto val : range) { occurrence.add_range(val); } + if (enclosingLoc.has_value() && !enclosingLoc->empty()) { + auto encRange = sorbet::scip_indexer::fromSorbetLoc(gs, enclosingLoc.value()); + for (auto val : encRange) { + occurrence.add_enclosing_range(val); + } + } switch (emitted) { case Emitted::Now: break; @@ -396,7 +403,8 @@ class SCIPState { } public: - absl::Status saveDefinition(const core::GlobalState &gs, core::FileRef file, OwnedLocal occ, core::TypePtr type) { + absl::Status saveDefinition(const core::GlobalState &gs, core::FileRef file, OwnedLocal occ, core::TypePtr type, + optional enclosingLoc = nullopt) { if (this->cacheOccurrence(gs, file, occ, scip::SymbolRole::Definition)) { return absl::OkStatus(); } @@ -407,7 +415,7 @@ class SCIPState { ENFORCE(var.has_value(), "Failed to find source text for definition of local variable"); docStrings.push_back(fmt::format("```ruby\n{} ({})\n```", var.value(), type.show(gs))); } - return this->saveDefinitionImpl(gs, file, occ.toSCIPString(gs, file), loc, docStrings, {}); + return this->saveDefinitionImpl(gs, file, occ.toSCIPString(gs, file), loc, docStrings, {}, enclosingLoc); } void saveAliasRelationship(const core::GlobalState &gs, UntypedGenericSymbolRef aliasedSymbol, @@ -423,7 +431,8 @@ class SCIPState { // TODO(varun): Should we always pass in the location instead of sometimes only? absl::Status saveDefinition(const core::GlobalState &gs, core::FileRef file, GenericSymbolRef symRef, optional aliasedSymbol, - optional loc = nullopt) { + optional loc = nullopt, + optional enclosingLoc = nullopt) { // In practice, there doesn't seem to be any situation which triggers // a duplicate definition being emitted, so skip calling cacheOccurrence here. auto occLoc = loc.has_value() ? core::Loc(file, loc.value()) : symRef.symbolLoc(gs); @@ -452,7 +461,7 @@ class SCIPState { this->saveAliasRelationship(gs, aliasedSymbol.value(), rels); } - return this->saveDefinitionImpl(gs, file, symbolString, occLoc, docs, rels); + return this->saveDefinitionImpl(gs, file, symbolString, occLoc, docs, rels, enclosingLoc); } absl::Status saveReference(const core::GlobalState &gs, core::FileRef file, OwnedLocal occ, @@ -1491,7 +1500,8 @@ class SCIPSemanticExtension : public SemanticExtension { auto scipState = this->getSCIPState(); auto sym = scip_indexer::GenericSymbolRef::classOrModule(klass.symbol); - auto status = scipState->saveDefinition(gs, file, sym, /*aliasedSymbol*/ nullopt, nameLoc); + auto klassLoc = core::Loc(file, klass.loc); + auto status = scipState->saveDefinition(gs, file, sym, /*aliasedSymbol*/ nullopt, nameLoc, klassLoc); ENFORCE(status.ok()); auto *expr = &klass.name; if (auto *constantLit = ast::cast_tree(*expr)) { @@ -1513,9 +1523,10 @@ class SCIPSemanticExtension : public SemanticExtension { return; } auto scipState = this->getSCIPState(); + auto methodLoc = core::Loc(file, methodDef.loc); if (methodDef.name != core::Names::staticInit()) { auto sym = scip_indexer::GenericSymbolRef::method(methodDef.symbol); - auto status = scipState->saveDefinition(gs, file, sym, /*aliasedSymbol*/ nullopt); + auto status = scipState->saveDefinition(gs, file, sym, /*aliasedSymbol*/ nullopt, /*loc*/ nullopt, methodLoc); ENFORCE(status.ok()); } diff --git a/test/scip/testdata/abstract_interface.snapshot.rb b/test/scip/testdata/abstract_interface.snapshot.rb index 12c4f3eb6..cdd7df57e 100644 --- a/test/scip/testdata/abstract_interface.snapshot.rb +++ b/test/scip/testdata/abstract_interface.snapshot.rb @@ -2,6 +2,7 @@ # Exercises abstract!, interface!, final!, sealed!, mixes_in_class_methods. +#⌄ enclosing_range_start [..] Drawable# module Drawable # ^^^^^^^^ definition [..] Drawable# extend T::Sig @@ -12,10 +13,14 @@ module Drawable sig { abstract.returns(String) } # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] Drawable#draw(). def draw; end # ^^^^ definition [..] Drawable#draw(). +# ⌃ enclosing_range_end [..] Drawable#draw(). end +# ⌃ enclosing_range_end [..] Drawable# +#⌄ enclosing_range_start [..] Shape# class Shape # ^^^^^ definition [..] Shape# extend T::Sig @@ -26,10 +31,14 @@ class Shape sig { abstract.returns(Integer) } # ^^^^^^^ reference [..] Integer# +# ⌄ enclosing_range_start [..] Shape#area(). def area; end # ^^^^ definition [..] Shape#area(). +# ⌃ enclosing_range_end [..] Shape#area(). end +# ⌃ enclosing_range_end [..] Shape# +#⌄ enclosing_range_start [..] Square# class Square < Shape # ^^^^^^ definition [..] Square# # ^^^^^ reference [..] Shape# @@ -42,19 +51,25 @@ class Square < Shape sig { override.returns(Integer) } # ^^^^^^^ reference [..] Integer# +# ⌄ enclosing_range_start [..] Square#area(). def area # ^^^^ definition [..] Square#area(). 16 end +# ⌃ enclosing_range_end [..] Square#area(). sig { override.returns(String) } # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] Square#draw(). def draw # ^^^^ definition [..] Square#draw(). "square" end +# ⌃ enclosing_range_end [..] Square#draw(). end +# ⌃ enclosing_range_end [..] Square# +#⌄ enclosing_range_start [..] FinalLeaf# class FinalLeaf # ^^^^^^^^^ definition [..] FinalLeaf# extend T::Sig @@ -65,19 +80,25 @@ class FinalLeaf sig(:final) { returns(Integer) } # ^^^^^^^ reference [..] Integer# +# ⌄ enclosing_range_start [..] FinalLeaf#value(). def value # ^^^^^ definition [..] FinalLeaf#value(). 42 end +# ⌃ enclosing_range_end [..] FinalLeaf#value(). end +# ⌃ enclosing_range_end [..] FinalLeaf# +#⌄ enclosing_range_start [..] SealedHierarchy# module SealedHierarchy # ^^^^^^^^^^^^^^^ definition [..] SealedHierarchy# extend T::Helpers # ^^^^^^ reference [..] Kernel#extend(). sealed! end +# ⌃ enclosing_range_end [..] SealedHierarchy# +#⌄ enclosing_range_start [..] ClassMethodsMixin# module ClassMethodsMixin # ^^^^^^^^^^^^^^^^^ definition [..] ClassMethodsMixin# extend T::Sig @@ -85,12 +106,16 @@ module ClassMethodsMixin sig { returns(String) } # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] ClassMethodsMixin#class_helper(). def class_helper # ^^^^^^^^^^^^ definition [..] ClassMethodsMixin#class_helper(). "class!" end +# ⌃ enclosing_range_end [..] ClassMethodsMixin#class_helper(). end +# ⌃ enclosing_range_end [..] ClassMethodsMixin# +#⌄ enclosing_range_start [..] InstanceMethodsMixin# module InstanceMethodsMixin # ^^^^^^^^^^^^^^^^^^^^ definition [..] InstanceMethodsMixin# extend T::Helpers @@ -98,7 +123,9 @@ module InstanceMethodsMixin mixes_in_class_methods(ClassMethodsMixin) # ^^^^^^^^^^^^^^^^^ reference [..] ClassMethodsMixin# end +# ⌃ enclosing_range_end [..] InstanceMethodsMixin# +#⌄ enclosing_range_start [..] WithMixedIn# class WithMixedIn # ^^^^^^^^^^^ definition [..] WithMixedIn# include InstanceMethodsMixin @@ -106,3 +133,4 @@ class WithMixedIn # ^^^^^^^^^^^^^^^^^^^^ reference [..] InstanceMethodsMixin# # ^^^^^^^^^^^^^^^^^^^^ reference [..] InstanceMethodsMixin# end +# ⌃ enclosing_range_end [..] WithMixedIn# diff --git a/test/scip/testdata/alias.snapshot.rb b/test/scip/testdata/alias.snapshot.rb index c1640f11f..cd8b04c4e 100644 --- a/test/scip/testdata/alias.snapshot.rb +++ b/test/scip/testdata/alias.snapshot.rb @@ -1,32 +1,41 @@ # typed: true +#⌄ enclosing_range_start [..] X# class X # ^ definition [..] X# alias_method :am_aaa, :aaa # ^^^^^^^^^^^^ reference [..] Module#alias_method(). alias :a_aaa :aaa +# ⌄ enclosing_range_start [..] X#aaa(). def aaa # ^^^ definition [..] X#aaa(). puts "AAA" # ^^^^ reference [..] Kernel#puts(). end +# ⌃ enclosing_range_end [..] X#aaa(). +# ⌄ enclosing_range_start [..] X#check_alias(). def check_alias # ^^^^^^^^^^^ definition [..] X#check_alias(). return [am_aaa, a_aaa] # ^^^^^^ reference [..] X#aaa(). # ^^^^^ reference [..] X#aaa(). end +# ⌃ enclosing_range_end [..] X#check_alias(). end +# ⌃ enclosing_range_end [..] X# +#⌄ enclosing_range_start [..] Mod1# module Mod1 # ^^^^ definition [..] Mod1# ABC = 10 # ^^^ definition [..] Mod1#ABC. # ^^^^^^^^ reference [..] Mod1#ABC. end +# ⌃ enclosing_range_end [..] Mod1# +#⌄ enclosing_range_start [..] Mod2# module Mod2 # ^^^^ definition [..] Mod2# FEG = Mod1::ABC @@ -36,7 +45,9 @@ module Mod2 # ^^^ reference [..] Mod1#ABC. # ^^^ reference [..] Mod2#FEG. end +# ⌃ enclosing_range_end [..] Mod2# +#⌄ enclosing_range_start [..] Object#myfunction(). def myfunction(myparam) # ^^^^^^^^^^ definition [..] Object#myfunction(). # ^^^^^^^ definition local 1$3083414419 @@ -45,7 +56,10 @@ def myfunction(myparam) # ^^^^ reference [..] Mod2# # ^^^ reference [..] Mod2#FEG. end +# ⌃ enclosing_range_end [..] Object#myfunction(). +#⌄ enclosing_range_start [..] X# +#⌄ enclosing_range_start [..] X#serialize(). class X < T::Enum # ^ definition [..] X# # ^ definition [..] X#serialize(). @@ -73,9 +87,12 @@ class X < T::Enum # ^^^^^^^^ definition local 4$119448696 # ^ reference [..] X# end +# ⌃ enclosing_range_end [..] X# +# ⌃ enclosing_range_end [..] X#serialize(). # Adding more cases like this is not supported (c.f. isTEnum), # but let's at least add a test. +#⌄ enclosing_range_start [..] Y# class Y < X # ^ definition [..] Y# # ^ reference [..] X# @@ -90,3 +107,4 @@ class Y < X # ^ reference [..] X#B. end end +# ⌃ enclosing_range_end [..] Y# diff --git a/test/scip/testdata/args.snapshot.rb b/test/scip/testdata/args.snapshot.rb index 45234e914..512c56401 100644 --- a/test/scip/testdata/args.snapshot.rb +++ b/test/scip/testdata/args.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Object#args(). def args(x, y) # ^^^^ definition [..] Object#args(). # ^ definition local 1$2634721084 @@ -24,7 +25,9 @@ def args(x, y) z # ^ reference local 3$2634721084 end +# ⌃ enclosing_range_end [..] Object#args(). +#⌄ enclosing_range_start [..] Object#keyword_args(). def keyword_args(w:, x: 3, y: [], **kwargs) # ^^^^^^^^^^^^ definition [..] Object#keyword_args(). # ^^ definition local 1$3526982640 @@ -38,7 +41,9 @@ def keyword_args(w:, x: 3, y: [], **kwargs) # ^ reference local 3$3526982640 return end +# ⌃ enclosing_range_end [..] Object#keyword_args(). +#⌄ enclosing_range_start [..] Object#use_kwargs(). def use_kwargs # ^^^^^^^^^^ definition [..] Object#use_kwargs(). h = { a: 3 } @@ -51,3 +56,4 @@ def use_kwargs # ^ reference local 1$571973038 return end +# ⌃ enclosing_range_end [..] Object#use_kwargs(). diff --git a/test/scip/testdata/arrays.snapshot.rb b/test/scip/testdata/arrays.snapshot.rb index f58f59683..04e157ad8 100644 --- a/test/scip/testdata/arrays.snapshot.rb +++ b/test/scip/testdata/arrays.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Object#arrays(). def arrays(a, i) # ^^^^^^ definition [..] Object#arrays(). # ^ definition local 1$513334479 @@ -21,3 +22,4 @@ def arrays(a, i) # ^ reference local 1$513334479 # ^ reference local 1$513334479 end +# ⌃ enclosing_range_end [..] Object#arrays(). diff --git a/test/scip/testdata/blocks_lambdas_procs.snapshot.rb b/test/scip/testdata/blocks_lambdas_procs.snapshot.rb index 0aa23ea48..e4a32b671 100644 --- a/test/scip/testdata/blocks_lambdas_procs.snapshot.rb +++ b/test/scip/testdata/blocks_lambdas_procs.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Object#blk(). def blk # ^^^ definition [..] Object#blk(). y = 0 @@ -21,7 +22,9 @@ def blk # ^ reference local 3$1472469056 end end +# ⌃ enclosing_range_end [..] Object#blk(). +#⌄ enclosing_range_start [..] Object#lam(). def lam # ^^^ definition [..] Object#lam(). y = 0 @@ -81,7 +84,9 @@ def lam # ^^ reference local 11$1499497673 # ^^^^ reference [..] Proc#call(). end +# ⌃ enclosing_range_end [..] Object#lam(). +#⌄ enclosing_range_start [..] Object#prc(). def prc # ^^^ definition [..] Object#prc(). y = 0 @@ -141,14 +146,18 @@ def prc # ^^ reference local 11$1283111692 # ^^^^ reference [..] Proc#call(). end +# ⌃ enclosing_range_end [..] Object#prc(). +#⌄ enclosing_range_start [..] Object#call_block(). def call_block(&blk) # ^^^^^^^^^^ definition [..] Object#call_block(). # ^^^ definition local 1$1487178087 blk.call # ^^^ reference local 1$1487178087 end +# ⌃ enclosing_range_end [..] Object#call_block(). +#⌄ enclosing_range_start [..] Object#use_block_with_defaults(). def use_block_with_defaults # ^^^^^^^^^^^^^^^^^^^^^^^ definition [..] Object#use_block_with_defaults(). call_block do |oops: nil| @@ -161,3 +170,4 @@ def use_block_with_defaults # ^^^^ definition local 2$4118119342 end end +# ⌃ enclosing_range_end [..] Object#use_block_with_defaults(). diff --git a/test/scip/testdata/call.snapshot.rb b/test/scip/testdata/call.snapshot.rb index 4db8c75c8..40368f6a2 100644 --- a/test/scip/testdata/call.snapshot.rb +++ b/test/scip/testdata/call.snapshot.rb @@ -4,13 +4,16 @@ # accidentally skipping emitting references for the method body # due to changes in rewriter/Command.cc +#⌄ enclosing_range_start [..] Opus#Command# class Opus::Command # ^^^^ reference [..] Opus# # ^^^^^^^ definition [..] Opus#Command# end +# ⌃ enclosing_range_end [..] Opus#Command# # NOTE: This is nested inside Opus as a convention, # but the key thing is the subclassing relationship. +#⌄ enclosing_range_start [..] Opus#MyThing#Command#GetThing# class Opus::MyThing::Command::GetThing < Opus::Command # ^^^^ reference [..] Opus# # ^^^^^^^ reference [..] Opus#MyThing# @@ -18,6 +21,7 @@ class Opus::MyThing::Command::GetThing < Opus::Command # ^^^^^^^^ definition [..] Opus#MyThing#Command#GetThing# # ^^^^ reference [..] Opus# # ^^^^^^^ reference [..] Opus#Command# +# ⌄ enclosing_range_start [..] Opus#MyThing#Command#GetThing#call(). def call() # ^^^^ definition [..] Opus#MyThing#Command#GetThing#call(). x = 1 @@ -27,14 +31,18 @@ def call() # ^^^^^ reference local 2$3018949801 # ^ reference local 1$3018949801 end +# ⌃ enclosing_range_end [..] Opus#MyThing#Command#GetThing#call(). end +# ⌃ enclosing_range_end [..] Opus#MyThing#Command#GetThing# # Forgot < Opus::Command relationship here +#⌄ enclosing_range_start [..] Opus#MyThing#BadCommand#GetThing# class Opus::MyThing::BadCommand::GetThing # ^^^^ reference [..] Opus# # ^^^^^^^ reference [..] Opus#MyThing# # ^^^^^^^^^^ reference [..] Opus#MyThing#BadCommand# # ^^^^^^^^ definition [..] Opus#MyThing#BadCommand#GetThing# +# ⌄ enclosing_range_start [..] Opus#MyThing#BadCommand#GetThing#call(). def call() # ^^^^ definition [..] Opus#MyThing#BadCommand#GetThing#call(). x = 1 @@ -44,13 +52,17 @@ def call() # ^^^^^ reference local 2$3018949801 # ^ reference local 1$3018949801 end +# ⌃ enclosing_range_end [..] Opus#MyThing#BadCommand#GetThing#call(). end +# ⌃ enclosing_range_end [..] Opus#MyThing#BadCommand#GetThing# +#⌄ enclosing_range_start [..] NotOpus#Command1#GetThing# class NotOpus::Command1::GetThing # ^^^^^^^ reference [..] NotOpus# # ^^^^^^^^ reference [..] NotOpus#Command1# # ^^^^^^^^ definition [..] NotOpus#Command1#GetThing# # Class method +# ⌄ enclosing_range_start [..] NotOpus#Command1#``#call(). def self.call() # ^^^^ definition [..] NotOpus#Command1#``#call(). x = 1 @@ -60,13 +72,17 @@ def self.call() # ^^^^^ reference local 2$3018949801 # ^ reference local 1$3018949801 end +# ⌃ enclosing_range_end [..] NotOpus#Command1#``#call(). end +# ⌃ enclosing_range_end [..] NotOpus#Command1#GetThing# +#⌄ enclosing_range_start [..] NotOpus#Command2#GetThing# class NotOpus::Command2::GetThing # ^^^^^^^ reference [..] NotOpus# # ^^^^^^^^ reference [..] NotOpus#Command2# # ^^^^^^^^ definition [..] NotOpus#Command2#GetThing# # Instance method +# ⌄ enclosing_range_start [..] NotOpus#Command2#GetThing#call(). def call() # ^^^^ definition [..] NotOpus#Command2#GetThing#call(). x = 1 @@ -76,8 +92,11 @@ def call() # ^^^^^ reference local 2$3018949801 # ^ reference local 1$3018949801 end +# ⌃ enclosing_range_end [..] NotOpus#Command2#GetThing#call(). end +# ⌃ enclosing_range_end [..] NotOpus#Command2#GetThing# +#⌄ enclosing_range_start [..] Object#make_call(). def make_call() # ^^^^^^^^^ definition [..] Object#make_call(). # Should navigate to instance method @@ -107,3 +126,4 @@ def make_call() # ^^^ reference [..] Class#new(). # ^^^^ reference [..] NotOpus#Command2#GetThing#call(). end +# ⌃ enclosing_range_end [..] Object#make_call(). diff --git a/test/scip/testdata/cattr.snapshot.rb b/test/scip/testdata/cattr.snapshot.rb index 80f23bdf2..4ccc786c9 100644 --- a/test/scip/testdata/cattr.snapshot.rb +++ b/test/scip/testdata/cattr.snapshot.rb @@ -1,26 +1,43 @@ # typed: strict +#⌄ enclosing_range_start [..] CR# class CR # ^^ definition [..] CR# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] CR#both(). +# ⌄ enclosing_range_start [..] ``#both(). +# ⌄ enclosing_range_start [..] CR#foo(). +# ⌄ enclosing_range_start [..] ``#foo(). cattr_reader :both, :foo # ^^^^^ definition [..] CR#both(). # ^^^^^ definition [..] ``#both(). # ^^^^ definition [..] CR#foo(). # ^^^^ definition [..] ``#foo(). +# ⌃ enclosing_range_end [..] CR#both(). +# ⌃ enclosing_range_end [..] ``#both(). +# ⌃ enclosing_range_end [..] CR#foo(). +# ⌃ enclosing_range_end [..] ``#foo(). +# ⌄ enclosing_range_start [..] ``#no_instance(). cattr_reader :no_instance, instance_accessor: false # ^^^^^^^^^^^^ definition [..] ``#no_instance(). +# ⌃ enclosing_range_end [..] ``#no_instance(). +# ⌄ enclosing_range_start [..] ``#bar(). +# ⌄ enclosing_range_start [..] ``#no_reader(). cattr_reader :bar, :no_reader, instance_reader: false # ^^^^ definition [..] ``#bar(). # ^^^^^^^^^^ definition [..] ``#no_reader(). +# ⌃ enclosing_range_end [..] ``#bar(). +# ⌃ enclosing_range_end [..] ``#no_reader(). sig {void} +# ⌄ enclosing_range_start [..] CR#usages(). def usages # ^^^^^^ definition [..] CR#usages(). both # ^^^^ reference [..] CR#both(). end +# ⌃ enclosing_range_end [..] CR#usages(). both # ^^^^ reference [..] ``#both(). @@ -29,28 +46,46 @@ def usages no_reader # ^^^^^^^^^ reference [..] ``#no_reader(). end +# ⌃ enclosing_range_end [..] CR# +#⌄ enclosing_range_start [..] CW# class CW # ^^ definition [..] CW# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] CW#`both=`(). +# ⌄ enclosing_range_start [..] ``#`both=`(). +# ⌄ enclosing_range_start [..] CW#`foo=`(). +# ⌄ enclosing_range_start [..] ``#`foo=`(). cattr_writer :both, :foo # ^^^^^ definition [..] CW#`both=`(). # ^^^^^ definition [..] ``#`both=`(). # ^^^^ definition [..] CW#`foo=`(). # ^^^^ definition [..] ``#`foo=`(). +# ⌃ enclosing_range_end [..] CW#`both=`(). +# ⌃ enclosing_range_end [..] ``#`both=`(). +# ⌃ enclosing_range_end [..] CW#`foo=`(). +# ⌃ enclosing_range_end [..] ``#`foo=`(). +# ⌄ enclosing_range_start [..] ``#`no_instance=`(). cattr_writer :no_instance, instance_accessor: false # ^^^^^^^^^^^^ definition [..] ``#`no_instance=`(). +# ⌃ enclosing_range_end [..] ``#`no_instance=`(). +# ⌄ enclosing_range_start [..] ``#`bar=`(). +# ⌄ enclosing_range_start [..] ``#`no_instance_writer=`(). cattr_writer :bar, :no_instance_writer, instance_writer: false # ^^^^ definition [..] ``#`bar=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#`no_instance_writer=`(). +# ⌃ enclosing_range_end [..] ``#`bar=`(). +# ⌃ enclosing_range_end [..] ``#`no_instance_writer=`(). sig {void} +# ⌄ enclosing_range_start [..] CW#usages(). def usages # ^^^^^^ definition [..] CW#usages(). self.both = 1 # ^^^^^^ reference [..] CW#`both=`(). end +# ⌃ enclosing_range_end [..] CW#usages(). self.both = 1 # ^^^^^^ reference [..] ``#`both=`(). @@ -59,11 +94,21 @@ def usages self.no_instance_writer = 1 # ^^^^^^^^^^^^^^^^^^^^ reference [..] ``#`no_instance_writer=`(). end +# ⌃ enclosing_range_end [..] CW# +#⌄ enclosing_range_start [..] CA# class CA # ^^ definition [..] CA# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] CA#`both=`(). +# ⌄ enclosing_range_start [..] CA#both(). +# ⌄ enclosing_range_start [..] ``#`both=`(). +# ⌄ enclosing_range_start [..] ``#both(). +# ⌄ enclosing_range_start [..] CA#`foo=`(). +# ⌄ enclosing_range_start [..] CA#foo(). +# ⌄ enclosing_range_start [..] ``#`foo=`(). +# ⌄ enclosing_range_start [..] ``#foo(). cattr_accessor :both, :foo # ^^^^^ definition [..] CA#both(). # ^^^^^ definition [..] CA#`both=`(). @@ -73,13 +118,37 @@ class CA # ^^^^ definition [..] CA#foo(). # ^^^^ definition [..] ``#`foo=`(). # ^^^^ definition [..] ``#foo(). +# ⌃ enclosing_range_end [..] CA#`both=`(). +# ⌃ enclosing_range_end [..] CA#both(). +# ⌃ enclosing_range_end [..] ``#`both=`(). +# ⌃ enclosing_range_end [..] ``#both(). +# ⌃ enclosing_range_end [..] CA#`foo=`(). +# ⌃ enclosing_range_end [..] CA#foo(). +# ⌃ enclosing_range_end [..] ``#`foo=`(). +# ⌃ enclosing_range_end [..] ``#foo(). +# ⌄ enclosing_range_start [..] ``#`no_instance=`(). +# ⌄ enclosing_range_start [..] ``#no_instance(). cattr_accessor :no_instance, instance_accessor: false # ^^^^^^^^^^^^ definition [..] ``#`no_instance=`(). # ^^^^^^^^^^^^ definition [..] ``#no_instance(). +# ⌃ enclosing_range_end [..] ``#`no_instance=`(). +# ⌃ enclosing_range_end [..] ``#no_instance(). +# ⌄ enclosing_range_start [..] CA#`no_instance_reader=`(). +# ⌄ enclosing_range_start [..] ``#`no_instance_reader=`(). +# ⌄ enclosing_range_start [..] ``#no_instance_reader(). cattr_accessor :no_instance_reader, instance_reader: false # ^^^^^^^^^^^^^^^^^^^ definition [..] CA#`no_instance_reader=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#`no_instance_reader=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#no_instance_reader(). +# ⌃ enclosing_range_end [..] CA#`no_instance_reader=`(). +# ⌃ enclosing_range_end [..] ``#`no_instance_reader=`(). +# ⌃ enclosing_range_end [..] ``#no_instance_reader(). +# ⌄ enclosing_range_start [..] CA#bar(). +# ⌄ enclosing_range_start [..] ``#`bar=`(). +# ⌄ enclosing_range_start [..] ``#bar(). +# ⌄ enclosing_range_start [..] CA#no_instance_writer(). +# ⌄ enclosing_range_start [..] ``#`no_instance_writer=`(). +# ⌄ enclosing_range_start [..] ``#no_instance_writer(). cattr_accessor :bar, :no_instance_writer, instance_writer: false # ^^^^ definition [..] CA#bar(). # ^^^^ definition [..] ``#`bar=`(). @@ -87,8 +156,15 @@ class CA # ^^^^^^^^^^^^^^^^^^^ definition [..] CA#no_instance_writer(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#`no_instance_writer=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#no_instance_writer(). +# ⌃ enclosing_range_end [..] CA#bar(). +# ⌃ enclosing_range_end [..] ``#`bar=`(). +# ⌃ enclosing_range_end [..] ``#bar(). +# ⌃ enclosing_range_end [..] CA#no_instance_writer(). +# ⌃ enclosing_range_end [..] ``#`no_instance_writer=`(). +# ⌃ enclosing_range_end [..] ``#no_instance_writer(). sig {void} +# ⌄ enclosing_range_start [..] CA#usages(). def usages # ^^^^^^ definition [..] CA#usages(). both @@ -100,6 +176,7 @@ def usages no_instance_writer # ^^^^^^^^^^^^^^^^^^ reference [..] CA#no_instance_writer(). end +# ⌃ enclosing_range_end [..] CA#usages(). both # ^^^^ reference [..] ``#both(). @@ -121,3 +198,4 @@ def usages self.no_instance_writer = 1 # ^^^^^^^^^^^^^^^^^^^^ reference [..] ``#`no_instance_writer=`(). end +# ⌃ enclosing_range_end [..] CA# diff --git a/test/scip/testdata/classes.snapshot.rb b/test/scip/testdata/classes.snapshot.rb index 734f98d4f..0204d18d0 100644 --- a/test/scip/testdata/classes.snapshot.rb +++ b/test/scip/testdata/classes.snapshot.rb @@ -3,8 +3,10 @@ _ = 0 #^ definition local 1$119448696 +#⌄ enclosing_range_start [..] C1# class C1 # ^^ definition [..] C1# +# ⌄ enclosing_range_start [..] C1#f(). def f() # ^ definition [..] C1#f(). _a = C1.new @@ -18,20 +20,29 @@ def f() # ^^^ reference [..] Class#new(). return end +# ⌃ enclosing_range_end [..] C1#f(). end +# ⌃ enclosing_range_end [..] C1# +#⌄ enclosing_range_start [..] M2# module M2 # ^^ definition [..] M2# +# ⌄ enclosing_range_start [..] M2#C2# class C2 # ^^ definition [..] M2#C2# end +# ⌃ enclosing_range_end [..] M2#C2# end +# ⌃ enclosing_range_end [..] M2# +#⌄ enclosing_range_start [..] M3#C3# class M3::C3 # ^^ reference [..] M3# # ^^ definition [..] M3#C3# end +# ⌃ enclosing_range_end [..] M3#C3# +#⌄ enclosing_range_start [..] Object#local_class(). def local_class() # ^^^^^^^^^^^ definition [..] Object#local_class(). localClass = Class.new @@ -40,10 +51,12 @@ def local_class() # ^^^ reference [..] ``#new(). # Technically, this is not supported by Sorbet (https://srb.help/3001), # but make sure we don't crash or do something weird. +# ⌄ enclosing_range_start [..] Object#myMethod(). def localClass.myMethod() # ^^^^^^^^ definition [..] Object#myMethod(). ":)" end +# ⌃ enclosing_range_end [..] Object#myMethod(). _c = localClass.new # ^^ definition local 3$552113551 # ^^^^^^^^^^ reference local 1$552113551 @@ -55,14 +68,18 @@ def localClass.myMethod() # ^^^^^^^^ reference [..] Object#myMethod(). return end +# ⌃ enclosing_range_end [..] Object#local_class(). +#⌄ enclosing_range_start [..] M4# module M4 # ^^ definition [..] M4# K = 0 # ^ definition [..] M4#K. # ^^^^^ reference [..] M4#K. end +# ⌃ enclosing_range_end [..] M4# +#⌄ enclosing_range_start [..] Object#module_access(). def module_access() # ^^^^^^^^^^^^^ definition [..] Object#module_access(). _ = M4::K @@ -71,16 +88,23 @@ def module_access() # ^ reference [..] M4#K. return end +# ⌃ enclosing_range_end [..] Object#module_access(). +#⌄ enclosing_range_start [..] M5# module M5 # ^^ definition [..] M5# +# ⌄ enclosing_range_start [..] M5#M6# module M6 # ^^ definition [..] M5#M6# +# ⌄ enclosing_range_start [..] M5#``#g(). def self.g() # ^ definition [..] M5#``#g(). end +# ⌃ enclosing_range_end [..] M5#``#g(). end +# ⌃ enclosing_range_end [..] M5#M6# +# ⌄ enclosing_range_start [..] ``#h(). def self.h() # ^ definition [..] ``#h(). M6.g() @@ -88,17 +112,25 @@ def self.h() # ^ reference [..] M5#``#g(). return end +# ⌃ enclosing_range_end [..] ``#h(). end +# ⌃ enclosing_range_end [..] M5# +#⌄ enclosing_range_start [..] C7# class C7 # ^^ definition [..] C7# +# ⌄ enclosing_range_start [..] C7#M8# module M8 # ^^ definition [..] C7#M8# +# ⌄ enclosing_range_start [..] C7#``#i(). def self.i() # ^ definition [..] C7#``#i(). end +# ⌃ enclosing_range_end [..] C7#``#i(). end +# ⌃ enclosing_range_end [..] C7#M8# +# ⌄ enclosing_range_start [..] C7#j(). def j() # ^ definition [..] C7#j(). M8.i() @@ -106,4 +138,6 @@ def j() # ^ reference [..] C7#``#i(). return end +# ⌃ enclosing_range_end [..] C7#j(). end +# ⌃ enclosing_range_end [..] C7# diff --git a/test/scip/testdata/def_delegator.snapshot.rb b/test/scip/testdata/def_delegator.snapshot.rb index 5886ee237..81cf53d6b 100644 --- a/test/scip/testdata/def_delegator.snapshot.rb +++ b/test/scip/testdata/def_delegator.snapshot.rb @@ -3,66 +3,106 @@ require 'forwardable' #^^^^^^^ reference [..] Kernel#require(). +#⌄ enclosing_range_start [..] MyArray1# class MyArray1 # ^^^^^^^^ definition [..] MyArray1# +# ⌄ enclosing_range_start [..] MyArray1#`inner_array=`(). +# ⌄ enclosing_range_start [..] MyArray1#inner_array(). attr_accessor :inner_array # ^^^^^^^^^^^ definition [..] MyArray1#`inner_array=`(). # ^^^^^^^^^^^ definition [..] MyArray1#inner_array(). +# ⌃ enclosing_range_end [..] MyArray1#`inner_array=`(). +# ⌃ enclosing_range_end [..] MyArray1#inner_array(). extend Forwardable # ^^^^^^ reference [..] Kernel#extend(). # ^^^^^^^^^^^ reference [..] Forwardable# +# ⌄ enclosing_range_start [..] MyArray1#get_at_index(). def_delegator :@inner_array, :[], :get_at_index # ^^^^^^^^^^^^^ reference [..] Forwardable#def_delegator(). # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Proc# # ^^^^^^^^^^^^^ definition [..] MyArray1#get_at_index(). +# ⌃ enclosing_range_end [..] MyArray1#get_at_index(). end +# ⌃ enclosing_range_end [..] MyArray1# +#⌄ enclosing_range_start [..] MyArray2# class MyArray2 # ^^^^^^^^ definition [..] MyArray2# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] MyArray2#`inner_array=`(). +# ⌄ enclosing_range_start [..] MyArray2#inner_array(). attr_accessor :inner_array # ^^^^^^^^^^^ definition [..] MyArray2#`inner_array=`(). # ^^^^^^^^^^^ definition [..] MyArray2#inner_array(). +# ⌃ enclosing_range_end [..] MyArray2#`inner_array=`(). +# ⌃ enclosing_range_end [..] MyArray2#inner_array(). extend Forwardable # ^^^^^^ reference [..] Kernel#extend(). # ^^^^^^^^^^^ reference [..] Forwardable# +# ⌄ enclosing_range_start [..] MyArray2#get_at_index(). def_delegator :@inner_array, :[], :get_at_index # ^^^^^^^^^^^^^ reference [..] Forwardable#def_delegator(). # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Proc# # ^^^^^^^^^^^^^ definition [..] MyArray2#get_at_index(). +# ⌃ enclosing_range_end [..] MyArray2#get_at_index(). end +# ⌃ enclosing_range_end [..] MyArray2# +#⌄ enclosing_range_start [..] MyArray3# class MyArray3 # ^^^^^^^^ definition [..] MyArray3# +# ⌄ enclosing_range_start [..] MyArray3#`inner_array=`(). +# ⌄ enclosing_range_start [..] MyArray3#inner_array(). attr_accessor :inner_array # ^^^^^^^^^^^ definition [..] MyArray3#`inner_array=`(). # ^^^^^^^^^^^ definition [..] MyArray3#inner_array(). +# ⌃ enclosing_range_end [..] MyArray3#`inner_array=`(). +# ⌃ enclosing_range_end [..] MyArray3#inner_array(). extend Forwardable # ^^^^^^ reference [..] Kernel#extend(). # ^^^^^^^^^^^ reference [..] Forwardable# +# ⌄ enclosing_range_start [..] MyArray3#`<<`(). +# ⌄ enclosing_range_start [..] MyArray3#map(). +# ⌄ enclosing_range_start [..] MyArray3#size(). def_delegators :@inner_array, :size, :<<, :map # ^^^^^^^^^^^^^^ reference [..] Forwardable#def_delegators(). # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Proc# # ^^^^^ definition [..] MyArray3#size(). # ^^^ definition [..] MyArray3#`<<`(). # ^^^^ definition [..] MyArray3#map(). +# ⌃ enclosing_range_end [..] MyArray3#`<<`(). +# ⌃ enclosing_range_end [..] MyArray3#map(). +# ⌃ enclosing_range_end [..] MyArray3#size(). end +# ⌃ enclosing_range_end [..] MyArray3# +#⌄ enclosing_range_start [..] MyArray4# class MyArray4 # ^^^^^^^^ definition [..] MyArray4# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] MyArray4#`inner_array=`(). +# ⌄ enclosing_range_start [..] MyArray4#inner_array(). attr_accessor :inner_array # ^^^^^^^^^^^ definition [..] MyArray4#`inner_array=`(). # ^^^^^^^^^^^ definition [..] MyArray4#inner_array(). +# ⌃ enclosing_range_end [..] MyArray4#`inner_array=`(). +# ⌃ enclosing_range_end [..] MyArray4#inner_array(). extend Forwardable # ^^^^^^ reference [..] Kernel#extend(). # ^^^^^^^^^^^ reference [..] Forwardable# +# ⌄ enclosing_range_start [..] MyArray4#`<<`(). +# ⌄ enclosing_range_start [..] MyArray4#map(). +# ⌄ enclosing_range_start [..] MyArray4#size(). def_delegators :@inner_array, :size, :<<, :map # ^^^^^^^^^^^^^^ reference [..] Forwardable#def_delegators(). # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Proc# # ^^^^^ definition [..] MyArray4#size(). # ^^^ definition [..] MyArray4#`<<`(). # ^^^^ definition [..] MyArray4#map(). +# ⌃ enclosing_range_end [..] MyArray4#`<<`(). +# ⌃ enclosing_range_end [..] MyArray4#map(). +# ⌃ enclosing_range_end [..] MyArray4#size(). end +# ⌃ enclosing_range_end [..] MyArray4# diff --git a/test/scip/testdata/delegate.snapshot.rb b/test/scip/testdata/delegate.snapshot.rb index 7195a1d66..a51d1eeb7 100644 --- a/test/scip/testdata/delegate.snapshot.rb +++ b/test/scip/testdata/delegate.snapshot.rb @@ -1,22 +1,34 @@ # typed: true +#⌄ enclosing_range_start [..] MethodNameManipulation# class MethodNameManipulation # ^^^^^^^^^^^^^^^^^^^^^^ definition [..] MethodNameManipulation# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] MethodNameManipulation#ball(). delegate :ball, to: :thing, private: true, allow_nil: true # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Proc# # ^^^^^ definition [..] MethodNameManipulation#ball(). +# ⌃ enclosing_range_end [..] MethodNameManipulation#ball(). +# ⌄ enclosing_range_start [..] MethodNameManipulation#string_bar(). +# ⌄ enclosing_range_start [..] MethodNameManipulation#string_foo(). delegate :foo, :bar, prefix: 'string', to: :thing # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Proc# # ^^^^ definition [..] MethodNameManipulation#string_foo(). # ^^^^ definition [..] MethodNameManipulation#string_bar(). +# ⌃ enclosing_range_end [..] MethodNameManipulation#string_bar(). +# ⌃ enclosing_range_end [..] MethodNameManipulation#string_foo(). +# ⌄ enclosing_range_start [..] MethodNameManipulation#symbol_bar(). +# ⌄ enclosing_range_start [..] MethodNameManipulation#symbol_foo(). delegate :foo, :bar, prefix: :symbol, to: :thing # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Proc# # ^^^^ definition [..] MethodNameManipulation#symbol_foo(). # ^^^^ definition [..] MethodNameManipulation#symbol_bar(). +# ⌃ enclosing_range_end [..] MethodNameManipulation#symbol_bar(). +# ⌃ enclosing_range_end [..] MethodNameManipulation#symbol_foo(). sig {void} +# ⌄ enclosing_range_start [..] MethodNameManipulation#usages(). def usages # ^^^^^^ definition [..] MethodNameManipulation#usages(). ball(thing: 0) {} @@ -30,4 +42,6 @@ def usages symbol_bar(1, 2) {} # ^^^^^^^^^^ reference [..] MethodNameManipulation#symbol_bar(). end +# ⌃ enclosing_range_end [..] MethodNameManipulation#usages(). end +# ⌃ enclosing_range_end [..] MethodNameManipulation# diff --git a/test/scip/testdata/encrypted_prop.snapshot.rb b/test/scip/testdata/encrypted_prop.snapshot.rb index e74c21015..939398fe3 100644 --- a/test/scip/testdata/encrypted_prop.snapshot.rb +++ b/test/scip/testdata/encrypted_prop.snapshot.rb @@ -1,11 +1,14 @@ # typed: true # Minimal stub of Chalk implementation to support encrypted_prop +#⌄ enclosing_range_start [..] Chalk#ODM#Document# class Chalk::ODM::Document # ^^^^^ reference [..] Chalk# # ^^^ reference [..] Chalk#ODM# # ^^^^^^^^ definition [..] Chalk#ODM#Document# end +# ⌃ enclosing_range_end [..] Chalk#ODM#Document# +#⌄ enclosing_range_start [..] Opus#DB#Model#Mixins#Encryptable#EncryptedValue# class Opus::DB::Model::Mixins::Encryptable::EncryptedValue < Chalk::ODM::Document # ^^^^ reference [..] Opus# # ^^ reference [..] Opus#DB# @@ -17,15 +20,23 @@ class Opus::DB::Model::Mixins::Encryptable::EncryptedValue < Chalk::ODM::Documen # ^^^ reference [..] Chalk#ODM# # ^^^^^^^^ reference [..] Chalk#ODM#Document# end +# ⌃ enclosing_range_end [..] Opus#DB#Model#Mixins#Encryptable#EncryptedValue# +#⌄ enclosing_range_start [..] EncryptedProp# class EncryptedProp # ^^^^^^^^^^^^^ definition [..] EncryptedProp# include T::Props # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T# # ^^^^^ reference [..] T#Props# +# ⌄ enclosing_range_start [..] ``#encrypted_prop(). def self.encrypted_prop(opts={}); end # ^^^^^^^^^^^^^^ definition [..] ``#encrypted_prop(). +# ⌃ enclosing_range_end [..] ``#encrypted_prop(). +# ⌄ enclosing_range_start [..] EncryptedProp#`encrypted_foo=`(). +# ⌄ enclosing_range_start [..] EncryptedProp#`foo=`(). +# ⌄ enclosing_range_start [..] EncryptedProp#encrypted_foo(). +# ⌄ enclosing_range_start [..] EncryptedProp#foo(). encrypted_prop :foo # ^^^^^^^^^^^^^^^^^^^ reference [..] String# # ^^^^^^^^^^^^^^^^^^^ reference [..] Opus#DB# @@ -38,6 +49,12 @@ def self.encrypted_prop(opts={}); end # ^^^ definition [..] EncryptedProp#`foo=`(). # ^^^ definition [..] EncryptedProp#encrypted_foo(). # ^^^ definition [..] EncryptedProp#foo(). +# ⌃ enclosing_range_end [..] EncryptedProp#`encrypted_foo=`(). +# ⌃ enclosing_range_end [..] EncryptedProp#`foo=`(). +# ⌃ enclosing_range_end [..] EncryptedProp#encrypted_foo(). +# ⌃ enclosing_range_end [..] EncryptedProp#foo(). +# ⌄ enclosing_range_start [..] EncryptedProp#bar(). +# ⌄ enclosing_range_start [..] EncryptedProp#encrypted_bar(). encrypted_prop :bar, migrating: true, immutable: true # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Opus#DB#Model#Mixins#Encryptable# # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Opus#DB# @@ -48,9 +65,13 @@ def self.encrypted_prop(opts={}); end # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] String# # ^^^ definition [..] EncryptedProp#bar(). # ^^^ definition [..] EncryptedProp#encrypted_bar(). +# ⌃ enclosing_range_end [..] EncryptedProp#bar(). +# ⌃ enclosing_range_end [..] EncryptedProp#encrypted_bar(). end +# ⌃ enclosing_range_end [..] EncryptedProp# +#⌄ enclosing_range_start [..] Object#f(). def f # ^ definition [..] Object#f(). EncryptedProp.new.foo = "hello" @@ -66,3 +87,4 @@ def f # ^^^ reference [..] Class#new(). # ^^^^^^^^^^^^^ reference [..] EncryptedProp#encrypted_foo(). end +# ⌃ enclosing_range_end [..] Object#f(). diff --git a/test/scip/testdata/enum.snapshot.rb b/test/scip/testdata/enum.snapshot.rb index 38076423c..0d6203fc8 100644 --- a/test/scip/testdata/enum.snapshot.rb +++ b/test/scip/testdata/enum.snapshot.rb @@ -1,5 +1,7 @@ # typed: strict +#⌄ enclosing_range_start [..] X# +#⌄ enclosing_range_start [..] X#serialize(). class X < T::Enum # ^ definition [..] X# # ^ definition [..] X#serialize(). @@ -27,9 +29,12 @@ class X < T::Enum # ^^^^^^^^ definition local 4$119448696 # ^ reference [..] X# end +# ⌃ enclosing_range_end [..] X# +# ⌃ enclosing_range_end [..] X#serialize(). # Adding more cases like this is not supported (c.f. isTEnum), # but let's at least add a test. +#⌄ enclosing_range_start [..] Y# class Y < X # ^ definition [..] Y# # ^ reference [..] X# @@ -44,7 +49,9 @@ class Y < X # ^ reference [..] X#B. end end +# ⌃ enclosing_range_end [..] Y# +#⌄ enclosing_range_start [..] Object#use_abc(). def use_abc # ^^^^^^^ definition [..] Object#use_abc(). x = X::A @@ -53,3 +60,4 @@ def use_abc # ^ reference [..] X#A. return end +# ⌃ enclosing_range_end [..] Object#use_abc(). diff --git a/test/scip/testdata/field_inheritance.snapshot.rb b/test/scip/testdata/field_inheritance.snapshot.rb index 95b136c13..797d58008 100644 --- a/test/scip/testdata/field_inheritance.snapshot.rb +++ b/test/scip/testdata/field_inheritance.snapshot.rb @@ -3,26 +3,40 @@ # First, check that instance variables are propagated through # the inheritance chain. +#⌄ enclosing_range_start [..] C1# class C1 # ^^ definition [..] C1# +# ⌄ enclosing_range_start [..] C1#`h=`(). +# ⌄ enclosing_range_start [..] C1#h(). attr_accessor :h # ^ definition [..] C1#`h=`(). # ^ definition [..] C1#h(). +# ⌃ enclosing_range_end [..] C1#`h=`(). +# ⌃ enclosing_range_end [..] C1#h(). +# ⌄ enclosing_range_start [..] C1#`i=`(). +# ⌄ enclosing_range_start [..] C1#i(). attr_accessor :i # ^ definition [..] C1#`i=`(). # ^ definition [..] C1#i(). +# ⌃ enclosing_range_end [..] C1#`i=`(). +# ⌃ enclosing_range_end [..] C1#i(). +# ⌄ enclosing_range_start [..] C1#set_ivar(). def set_ivar # ^^^^^^^^ definition [..] C1#set_ivar(). @f = 1 # ^^ definition [..] C1#`@f`. return end +# ⌃ enclosing_range_end [..] C1#set_ivar(). end +# ⌃ enclosing_range_end [..] C1# +#⌄ enclosing_range_start [..] C2# class C2 < C1 # ^^ definition [..] C2# # ^^ reference [..] C1# +# ⌄ enclosing_range_start [..] C2#get_inherited_ivar(). def get_inherited_ivar # ^^^^^^^^^^^^^^^^^^ definition [..] C2#get_inherited_ivar(). return @f + @h @@ -31,7 +45,9 @@ def get_inherited_ivar # ^^ reference [..] C2#`@h`. # relation definition=[..] C1#`@h`. end +# ⌃ enclosing_range_end [..] C2#get_inherited_ivar(). +# ⌄ enclosing_range_start [..] C2#set_inherited_ivar(). def set_inherited_ivar # ^^^^^^^^^^^^^^^^^^ definition [..] C2#set_inherited_ivar(). @f = 10 @@ -39,24 +55,32 @@ def set_inherited_ivar # relation definition=[..] C1#`@f`. return end +# ⌃ enclosing_range_end [..] C2#set_inherited_ivar(). +# ⌄ enclosing_range_start [..] C2#set_new_ivar(). def set_new_ivar # ^^^^^^^^^^^^ definition [..] C2#set_new_ivar(). @g = 1 # ^^ definition [..] C2#`@g`. return end +# ⌃ enclosing_range_end [..] C2#set_new_ivar(). +# ⌄ enclosing_range_start [..] C2#get_new_ivar(). def get_new_ivar # ^^^^^^^^^^^^ definition [..] C2#get_new_ivar(). return @g # ^^^^^^^^^ reference [..] C2#`@g`. end +# ⌃ enclosing_range_end [..] C2#get_new_ivar(). end +# ⌃ enclosing_range_end [..] C2# +#⌄ enclosing_range_start [..] C3# class C3 < C2 # ^^ definition [..] C3# # ^^ reference [..] C2# +# ⌄ enclosing_range_start [..] C3#refs(). def refs # ^^^^ definition [..] C3#refs(). @f = @g + @i @@ -68,8 +92,11 @@ def refs # relation definition=[..] C1#`@i`. return end +# ⌃ enclosing_range_end [..] C3#refs(). end +# ⌃ enclosing_range_end [..] C3# +#⌄ enclosing_range_start [..] Object#c_check(). def c_check # ^^^^^^^ definition [..] Object#c_check(). C1.new.instance_variable_get(:@f) @@ -120,14 +147,17 @@ def c_check # ^^^^^^^^^^^^^^^^^^^^^ reference [..] Kernel#instance_variable_get(). return end +# ⌃ enclosing_range_end [..] Object#c_check(). # Now, check that class variables work as expected. +#⌄ enclosing_range_start [..] D1# class D1 # ^^ definition [..] D1# @@d1_v = 0 # ^^^^^^ definition [..] ``#`@@d1_v`. +# ⌄ enclosing_range_start [..] ``#set_x(). def self.set_x # ^^^^^ definition [..] ``#set_x(). @@d1_x = @@d1_v @@ -135,10 +165,13 @@ def self.set_x # ^^^^^^ reference [..] ``#`@@d1_v`. return end +# ⌃ enclosing_range_end [..] ``#set_x(). # BUG: Emitting a definition for 'self' here seems wrong. +# ⌄ enclosing_range_start [..] ``# class << self # ^^^^ definition [..] ``# +# ⌄ enclosing_range_start [..] ``#set_y(). def set_y # ^^^^^ definition [..] ``#set_y(). @@d1_y = @@d1_v @@ -146,12 +179,17 @@ def set_y # ^^^^^^^^^^^^^^^ reference [..] ``#`@@d1_y`. # ^^^^^^ reference [..] ``#`@@d1_v`. end +# ⌃ enclosing_range_end [..] ``#set_y(). end +# ⌃ enclosing_range_end [..] ``# end +# ⌃ enclosing_range_end [..] D1# +#⌄ enclosing_range_start [..] D2# class D2 < D1 # ^^ definition [..] D2# # ^^ reference [..] D1# +# ⌄ enclosing_range_start [..] ``#get(). def self.get # ^^^ definition [..] ``#get(). @@d2_x = @@d1_v + @@d1_x @@ -166,11 +204,15 @@ def self.get # ^^^^^^ reference [..] ``#`@@d1_z`. return end +# ⌃ enclosing_range_end [..] ``#get(). end +# ⌃ enclosing_range_end [..] D2# +#⌄ enclosing_range_start [..] D3# class D3 < D2 # ^^ definition [..] D3# # ^^ reference [..] D2# +# ⌄ enclosing_range_start [..] ``#get_2(). def self.get_2 # ^^^^^ definition [..] ``#get_2(). @@d1_v + @@d1_x @@ -188,8 +230,11 @@ def self.get_2 # relation definition=[..] ``#`@@d2_x`. return end +# ⌃ enclosing_range_end [..] ``#get_2(). end +# ⌃ enclosing_range_end [..] D3# +#⌄ enclosing_range_start [..] Object#f(). def f # ^ definition [..] Object#f(). D2.class_variable_get(:@@d1_v) @@ -225,9 +270,11 @@ def f # ^^^^^^^^^^^^^^^^^^ reference [..] Module#class_variable_get(). return end +# ⌃ enclosing_range_end [..] Object#f(). ## Check that pre-declared class variables work too +#⌄ enclosing_range_start [..] DD1# class DD1 # ^^^ definition [..] DD1# @@x = T.let(0, Integer) @@ -236,25 +283,32 @@ class DD1 # ^^^^^^^ definition local 1$119448696 # ^^^^^^^ reference [..] Integer# end +# ⌃ enclosing_range_end [..] DD1# +#⌄ enclosing_range_start [..] DD2# class DD2 < DD1 # ^^^ definition [..] DD2# # ^^^ reference [..] DD1# +# ⌄ enclosing_range_start [..] ``#get_x(). def self.get_x # ^^^^^ definition [..] ``#get_x(). @@x # ^^^ reference [..] ``#`@@x`. # relation definition=[..] ``#`@@x`. end +# ⌃ enclosing_range_end [..] ``#get_x(). end +# ⌃ enclosing_range_end [..] DD2# # Class instance variables are not inherited. +#⌄ enclosing_range_start [..] E1# class E1 # ^^ definition [..] E1# @x = 0 # ^^ definition [..] ``#`@x`. +# ⌄ enclosing_range_start [..] ``#set_x(). def self.set_x # ^^^^^ definition [..] ``#set_x(). @x = @y @@ -262,21 +316,27 @@ def self.set_x # ^^ reference [..] ``#`@y`. return end +# ⌃ enclosing_range_end [..] ``#set_x(). +# ⌄ enclosing_range_start [..] ``#set_y(). def self.set_y # ^^^^^ definition [..] ``#set_y(). @y = 10 # ^^ definition [..] ``#`@y`. return end +# ⌃ enclosing_range_end [..] ``#set_y(). end +# ⌃ enclosing_range_end [..] E1# +#⌄ enclosing_range_start [..] E2# class E2 < E1 # ^^ definition [..] E2# # ^^ reference [..] E1# @x = 0 # ^^ definition [..] ``#`@x`. +# ⌄ enclosing_range_start [..] ``#set_x_2(). def self.set_x_2 # ^^^^^^^ definition [..] ``#set_x_2(). @x = @y @@ -284,19 +344,25 @@ def self.set_x_2 # ^^ reference [..] ``#`@y`. return end +# ⌃ enclosing_range_end [..] ``#set_x_2(). +# ⌄ enclosing_range_start [..] ``#set_y_2(). def self.set_y_2 # ^^^^^^^ definition [..] ``#set_y_2(). @y = 10 # ^^ definition [..] ``#`@y`. # ^^^^^^^ reference [..] ``#`@y`. end +# ⌃ enclosing_range_end [..] ``#set_y_2(). end +# ⌃ enclosing_range_end [..] E2# # Declared fields are inherited the same way as undeclared fields +#⌄ enclosing_range_start [..] F1# class F1 # ^^ definition [..] F1# +# ⌄ enclosing_range_start [..] F1#initialize(). def initialize # ^^^^^^^^^^ definition [..] F1#initialize(). @x = T.let(0, Integer) @@ -305,13 +371,19 @@ def initialize # ^^^^^^^ definition local 1$3465713227 # ^^^^^^^ reference [..] Integer# end +# ⌃ enclosing_range_end [..] F1#initialize(). end +# ⌃ enclosing_range_end [..] F1# +#⌄ enclosing_range_start [..] F2# class F2 # ^^ definition [..] F2# +# ⌄ enclosing_range_start [..] F2#get_x(). def get_x # ^^^^^ definition [..] F2#get_x(). @x # ^^ reference [..] F2#`@x`. end +# ⌃ enclosing_range_end [..] F2#get_x(). end +# ⌃ enclosing_range_end [..] F2# diff --git a/test/scip/testdata/fields_and_attrs.snapshot.rb b/test/scip/testdata/fields_and_attrs.snapshot.rb index 0d30be825..c9a462dc6 100644 --- a/test/scip/testdata/fields_and_attrs.snapshot.rb +++ b/test/scip/testdata/fields_and_attrs.snapshot.rb @@ -3,8 +3,10 @@ # Useful SO discussion with examples for class variables and instance variables, # and how they interact with inheritance: https://stackoverflow.com/a/15773671/2682729 +#⌄ enclosing_range_start [..] K# class K # ^ definition [..] K# +# ⌄ enclosing_range_start [..] K#m1(). def m1 # ^^ definition [..] K#m1(). @f = 0 @@ -14,6 +16,8 @@ def m1 # ^^ reference [..] K#`@f`. return end +# ⌃ enclosing_range_end [..] K#m1(). +# ⌄ enclosing_range_start [..] K#m2(). def m2 # ^^ definition [..] K#m2(). @f = @g @@ -21,11 +25,15 @@ def m2 # ^^ reference [..] K#`@g`. return end +# ⌃ enclosing_range_end [..] K#m2(). end +# ⌃ enclosing_range_end [..] K# # Extended +#⌄ enclosing_range_start [..] K# class K # ^ definition [..] K# +# ⌄ enclosing_range_start [..] K#m3(). def m3 # ^^ definition [..] K#m3(). @g = @f @@ -33,15 +41,19 @@ def m3 # ^^ reference [..] K#`@f`. return end +# ⌃ enclosing_range_end [..] K#m3(). end +# ⌃ enclosing_range_end [..] K# # Class instance var +#⌄ enclosing_range_start [..] L# class L # ^ definition [..] L# @x = 10 # ^^ definition [..] ``#`@x`. @y = 9 # ^^ definition [..] ``#`@y`. +# ⌄ enclosing_range_start [..] ``#m1(). def self.m1 # ^^ definition [..] ``#m1(). @y = @x @@ -49,22 +61,28 @@ def self.m1 # ^^ reference [..] ``#`@x`. return end +# ⌃ enclosing_range_end [..] ``#m1(). +# ⌄ enclosing_range_start [..] L#m2(). def m2 # ^^ definition [..] L#m2(). # FIXME: Missing references self.class.y = self.class.x return end +# ⌃ enclosing_range_end [..] L#m2(). end +# ⌃ enclosing_range_end [..] L# # Class var +#⌄ enclosing_range_start [..] N# class N # ^ definition [..] N# @@a = 0 # ^^^ definition [..] ``#`@@a`. @@b = 1 # ^^^ definition [..] ``#`@@b`. +# ⌄ enclosing_range_start [..] ``#m1(). def self.m1 # ^^ definition [..] ``#m1(). @@b = @@a @@ -72,7 +90,9 @@ def self.m1 # ^^^ reference [..] ``#`@@a`. return end +# ⌃ enclosing_range_end [..] ``#m1(). +# ⌄ enclosing_range_start [..] N#m2(). def m2 # ^^ definition [..] N#m2(). @@b = @@a @@ -80,25 +100,39 @@ def m2 # ^^^ reference [..] ``#`@@a`. return end +# ⌃ enclosing_range_end [..] N#m2(). +# ⌄ enclosing_range_start [..] N#m3(). def m3 # ^^ definition [..] N#m3(). # FIXME: Missing references self.class.b = self.class.a end +# ⌃ enclosing_range_end [..] N#m3(). end +# ⌃ enclosing_range_end [..] N# # Accessors +#⌄ enclosing_range_start [..] P# class P # ^ definition [..] P# +# ⌄ enclosing_range_start [..] P#`a=`(). +# ⌄ enclosing_range_start [..] P#a(). attr_accessor :a # ^ definition [..] P#`a=`(). # ^ definition [..] P#a(). +# ⌃ enclosing_range_end [..] P#`a=`(). +# ⌃ enclosing_range_end [..] P#a(). +# ⌄ enclosing_range_start [..] P#r(). attr_reader :r # ^ definition [..] P#r(). +# ⌃ enclosing_range_end [..] P#r(). +# ⌄ enclosing_range_start [..] P#`w=`(). attr_writer :w # ^ definition [..] P#`w=`(). +# ⌃ enclosing_range_end [..] P#`w=`(). +# ⌄ enclosing_range_start [..] P#init(). def init # ^^^^ definition [..] P#init(). self.a = self.r @@ -108,7 +142,9 @@ def init # ^^^ reference [..] P#`w=`(). # ^ reference [..] P#a(). end +# ⌃ enclosing_range_end [..] P#init(). +# ⌄ enclosing_range_start [..] P#wrong_init(). def wrong_init # ^^^^^^^^^^ definition [..] P#wrong_init(). # Check that 'r' is a method access but 'a' and 'w' are locals @@ -120,8 +156,11 @@ def wrong_init # ^^^^^ reference local 2$1021288725 # ^ reference local 1$1021288725 end +# ⌃ enclosing_range_end [..] P#wrong_init(). end +# ⌃ enclosing_range_end [..] P# +#⌄ enclosing_range_start [..] Object#useP(). def useP # ^^^^ definition [..] Object#useP(). p = P.new @@ -139,3 +178,4 @@ def useP # ^ reference local 1$2121829932 # ^ reference [..] P#a(). end +# ⌃ enclosing_range_end [..] Object#useP(). diff --git a/test/scip/testdata/flatfile_dsl.snapshot.rb b/test/scip/testdata/flatfile_dsl.snapshot.rb index b063ce10b..aaadf5100 100644 --- a/test/scip/testdata/flatfile_dsl.snapshot.rb +++ b/test/scip/testdata/flatfile_dsl.snapshot.rb @@ -1,37 +1,61 @@ # typed: true +#⌄ enclosing_range_start [..] Record# class Record # ^^^^^^ definition [..] Record# +# ⌄ enclosing_range_start [..] ``#flatfile(). def self.flatfile; end # ^^^^^^^^ definition [..] ``#flatfile(). +# ⌃ enclosing_range_end [..] ``#flatfile(). +# ⌄ enclosing_range_start [..] ``#from(). def self.from(*_); end # ^^^^ definition [..] ``#from(). +# ⌃ enclosing_range_end [..] ``#from(). +# ⌄ enclosing_range_start [..] ``#pattern(). def self.pattern(*_); end # ^^^^^^^ definition [..] ``#pattern(). +# ⌃ enclosing_range_end [..] ``#pattern(). +# ⌄ enclosing_range_start [..] ``#field(). def self.field(*_); end # ^^^^^ definition [..] ``#field(). +# ⌃ enclosing_range_end [..] ``#field(). end +# ⌃ enclosing_range_end [..] Record# +#⌄ enclosing_range_start [..] Flatfile# class Flatfile < Record # ^^^^^^^^ definition [..] Flatfile# # ^^^^^^ reference [..] Record# flatfile do # ^^^^^^^^ reference [..] ``#flatfile(). +# ⌄ enclosing_range_start [..] Flatfile#`foo=`(). +# ⌄ enclosing_range_start [..] Flatfile#foo(). from 1..2, :foo # ^^^^ reference [..] ``#from(). # ^^^^ definition [..] Flatfile#`foo=`(). # ^^^^ definition [..] Flatfile#foo(). +# ⌃ enclosing_range_end [..] Flatfile#`foo=`(). +# ⌃ enclosing_range_end [..] Flatfile#foo(). +# ⌄ enclosing_range_start [..] Flatfile#`bar=`(). +# ⌄ enclosing_range_start [..] Flatfile#bar(). pattern(/A-Za-z/, :bar) # ^^^^^^^ reference [..] ``#pattern(). # ^^^^^^^^ reference [..] Regexp# # ^^^^ definition [..] Flatfile#`bar=`(). # ^^^^ definition [..] Flatfile#bar(). +# ⌃ enclosing_range_end [..] Flatfile#`bar=`(). +# ⌃ enclosing_range_end [..] Flatfile#bar(). +# ⌄ enclosing_range_start [..] Flatfile#`baz=`(). +# ⌄ enclosing_range_start [..] Flatfile#baz(). field :baz # ^^^^^ reference [..] ``#field(). # ^^^^ definition [..] Flatfile#`baz=`(). # ^^^^ definition [..] Flatfile#baz(). +# ⌃ enclosing_range_end [..] Flatfile#`baz=`(). +# ⌃ enclosing_range_end [..] Flatfile#baz(). end end +# ⌃ enclosing_range_end [..] Flatfile# t = Flatfile.new #^ definition local 1$119448696 diff --git a/test/scip/testdata/for.snapshot.rb b/test/scip/testdata/for.snapshot.rb index 762328ada..93e79d1d9 100644 --- a/test/scip/testdata/for.snapshot.rb +++ b/test/scip/testdata/for.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Object#for_loop(). def for_loop() # ^^^^^^^^ definition [..] Object#for_loop(). y = 0 @@ -23,3 +24,4 @@ def for_loop() y # ^ reference local 1$1120785331 end +# ⌃ enclosing_range_end [..] Object#for_loop(). diff --git a/test/scip/testdata/freeze_constants.snapshot.rb b/test/scip/testdata/freeze_constants.snapshot.rb index 65a850aa3..5701b3a88 100644 --- a/test/scip/testdata/freeze_constants.snapshot.rb +++ b/test/scip/testdata/freeze_constants.snapshot.rb @@ -27,6 +27,7 @@ #| ``` # ^ reference [..] X. +#⌄ enclosing_range_start [..] M# module M # ^ definition [..] M# # documentation @@ -53,3 +54,4 @@ module M # | ``` # ^ reference [..] X. end +# ⌃ enclosing_range_end [..] M# diff --git a/test/scip/testdata/functions.snapshot.rb b/test/scip/testdata/functions.snapshot.rb index f8aca60ec..34e254c04 100644 --- a/test/scip/testdata/functions.snapshot.rb +++ b/test/scip/testdata/functions.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Object#globalFn1(). def globalFn1() # ^^^^^^^^^ definition [..] Object#globalFn1(). x = 10 @@ -7,7 +8,9 @@ def globalFn1() x # ^ reference local 1$3846536873 end +# ⌃ enclosing_range_end [..] Object#globalFn1(). +#⌄ enclosing_range_start [..] Object#globalFn2(). def globalFn2() # ^^^^^^^^^ definition [..] Object#globalFn2(). x = globalFn1() @@ -15,8 +18,10 @@ def globalFn2() # ^^^^^^^^^^^^^^^ reference local 1$3796204016 # ^^^^^^^^^ reference [..] Object#globalFn1(). end +# ⌃ enclosing_range_end [..] Object#globalFn2(). # https://stackoverflow.com/questions/64322636/whats-the-3-dots-method-argument-in-ruby +#⌄ enclosing_range_start [..] Object#loopyDoopy(). def loopyDoopy(...) # ^^^^^^^^^^ definition [..] Object#loopyDoopy(). # ^^^ definition local 1$1182647655 @@ -26,3 +31,4 @@ def loopyDoopy(...) # ^^^^^^^^^^^^^^^ reference local 1$1182647655 return end +# ⌃ enclosing_range_end [..] Object#loopyDoopy(). diff --git a/test/scip/testdata/gem_metadata.snapshot.rb b/test/scip/testdata/gem_metadata.snapshot.rb index 8c6e505bc..0a8a08af2 100644 --- a/test/scip/testdata/gem_metadata.snapshot.rb +++ b/test/scip/testdata/gem_metadata.snapshot.rb @@ -1,16 +1,22 @@ # typed: true # gem-metadata: leet@1.3.3.7 +#⌄ enclosing_range_start leet 1.3.3.7 C# class C # ^ definition leet 1.3.3.7 C# +# ⌄ enclosing_range_start leet 1.3.3.7 C#m(). def m # ^ definition leet 1.3.3.7 C#m(). n # ^ reference leet 1.3.3.7 C#n(). end +# ⌃ enclosing_range_end leet 1.3.3.7 C#m(). +# ⌄ enclosing_range_start leet 1.3.3.7 C#n(). def n # ^ definition leet 1.3.3.7 C#n(). m # ^ reference leet 1.3.3.7 C#m(). end +# ⌃ enclosing_range_end leet 1.3.3.7 C#n(). end +# ⌃ enclosing_range_end leet 1.3.3.7 C# diff --git a/test/scip/testdata/generics.snapshot.rb b/test/scip/testdata/generics.snapshot.rb index ff75e5bc3..1d3c6f9f2 100644 --- a/test/scip/testdata/generics.snapshot.rb +++ b/test/scip/testdata/generics.snapshot.rb @@ -4,6 +4,7 @@ # scip_indexer/SCIPSymbolRef.cc symbolForExpr (Descriptor::TypeParameter, # Descriptor::Type). +#⌄ enclosing_range_start [..] GenericBox# class GenericBox # ^^^^^^^^^^ definition [..] GenericBox# extend T::Sig @@ -16,6 +17,7 @@ class GenericBox sig { params(x: Elem).void } # ^^^^ definition local 2$3465713227 +# ⌄ enclosing_range_start [..] GenericBox#initialize(). def initialize(x) # ^^^^^^^^^^ definition [..] GenericBox#initialize(). # ^ definition local 1$3465713227 @@ -24,15 +26,20 @@ def initialize(x) # ^^^^^^ reference [..] GenericBox#`@x`. # ^ reference local 1$3465713227 end +# ⌃ enclosing_range_end [..] GenericBox#initialize(). sig { returns(Elem) } +# ⌄ enclosing_range_start [..] GenericBox#get(). def get # ^^^ definition [..] GenericBox#get(). @x # ^^ reference [..] GenericBox#`@x`. end +# ⌃ enclosing_range_end [..] GenericBox#get(). end +# ⌃ enclosing_range_end [..] GenericBox# +#⌄ enclosing_range_start [..] MyGenericMixin# module MyGenericMixin # ^^^^^^^^^^^^^^ definition [..] MyGenericMixin# extend T::Generic @@ -41,7 +48,9 @@ module MyGenericMixin Item = type_member # ^^^^ definition local 2$119448696 end +# ⌃ enclosing_range_end [..] MyGenericMixin# +#⌄ enclosing_range_start [..] WithTypeTemplate# class WithTypeTemplate # ^^^^^^^^^^^^^^^^ definition [..] WithTypeTemplate# extend T::Generic @@ -50,21 +59,27 @@ class WithTypeTemplate Tag = type_template # ^^^ definition local 2$119448696 end +# ⌃ enclosing_range_end [..] WithTypeTemplate# +#⌄ enclosing_range_start [..] WithTypeParameters# class WithTypeParameters # ^^^^^^^^^^^^^^^^^^ definition [..] WithTypeParameters# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). sig { type_parameters(:U).params(x: T.type_parameter(:U)).returns(T.type_parameter(:U)) } +# ⌄ enclosing_range_start [..] WithTypeParameters#identity(). def identity(x) # ^^^^^^^^ definition [..] WithTypeParameters#identity(). # ^ definition local 1$2839884955 x # ^ reference local 1$2839884955 end +# ⌃ enclosing_range_end [..] WithTypeParameters#identity(). end +# ⌃ enclosing_range_end [..] WithTypeParameters# +#⌄ enclosing_range_start [..] Object#use_generics(). def use_generics # ^^^^^^^^^^^^ definition [..] Object#use_generics(). box = GenericBox.new(1) @@ -82,3 +97,4 @@ def use_generics # ^^^^^^^^ reference [..] WithTypeParameters#identity(). return end +# ⌃ enclosing_range_end [..] Object#use_generics(). diff --git a/test/scip/testdata/globals.snapshot.rb b/test/scip/testdata/globals.snapshot.rb index 7a8b1b3f7..382626c30 100644 --- a/test/scip/testdata/globals.snapshot.rb +++ b/test/scip/testdata/globals.snapshot.rb @@ -3,6 +3,7 @@ $aa = 0 #^^^ definition [global] `>`#$aa. +#⌄ enclosing_range_start [..] Object#f(). def f # ^ definition [..] Object#f(). $aa = 10 @@ -15,9 +16,12 @@ def f # ^^^ reference [global] `>`#$bb. return end +# ⌃ enclosing_range_end [..] Object#f(). +#⌄ enclosing_range_start [..] C# class C # ^ definition [..] C# +# ⌄ enclosing_range_start [..] C#g(). def g # ^ definition [..] C#g(). $c = $bb @@ -25,7 +29,9 @@ def g # ^^^^^^^^ reference [global] `>`#$c. # ^^^ reference [global] `>`#$bb. end +# ⌃ enclosing_range_end [..] C#g(). end +# ⌃ enclosing_range_end [..] C# puts $c #^^^^ reference [..] Kernel#puts(). @@ -36,8 +42,10 @@ def g # ^^^^^^^ definition local 3$119448696 # ^^^^^^^ reference [..] Integer# +#⌄ enclosing_range_start [..] Object#g(). def g # ^ definition [..] Object#g(). $d # ^^ reference [global] `>`#$d. end +# ⌃ enclosing_range_end [..] Object#g(). diff --git a/test/scip/testdata/hashes.snapshot.rb b/test/scip/testdata/hashes.snapshot.rb index eaccd6678..75ae93f61 100644 --- a/test/scip/testdata/hashes.snapshot.rb +++ b/test/scip/testdata/hashes.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Object#hashes(). def hashes(h, k) # ^^^^^^ definition [..] Object#hashes(). # ^ definition local 1$1685166589 @@ -15,3 +16,4 @@ def hashes(h, k) # ^ reference local 1$1685166589 # ^^^ reference local 3$1685166589 end +# ⌃ enclosing_range_end [..] Object#hashes(). diff --git a/test/scip/testdata/hoverdocs.snapshot.rb b/test/scip/testdata/hoverdocs.snapshot.rb index 11380269a..4e46a1a36 100644 --- a/test/scip/testdata/hoverdocs.snapshot.rb +++ b/test/scip/testdata/hoverdocs.snapshot.rb @@ -2,6 +2,7 @@ # options: showDocs # Class doc comment +#⌄ enclosing_range_start [..] C1# class C1 # ^^ definition [..] C1# # documentation @@ -13,6 +14,7 @@ class C1 extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] C1#m1(). def m1 # ^^ definition [..] C1#m1(). # documentation @@ -21,9 +23,11 @@ def m1 # | def m1 # | ``` end +# ⌃ enclosing_range_end [..] C1#m1(). sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] C1#m2(). def m2 # ^^ definition [..] C1#m2(). # documentation @@ -33,10 +37,12 @@ def m2 # | ``` true end +# ⌃ enclosing_range_end [..] C1#m2(). sig { params(C, T::Boolean).returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] C1#m3(). def m3(c, b) # ^^ definition [..] C1#m3(). # documentation @@ -58,9 +64,11 @@ def m3(c, b) # ^ reference local 1$2519626513 # ^ reference local 2$2519626513 end +# ⌃ enclosing_range_end [..] C1#m3(). # _This_ is a # **doc comment.** +# ⌄ enclosing_range_start [..] C1#m4(). def m4(xs) # ^^ definition [..] C1#m4(). # documentation @@ -79,11 +87,13 @@ def m4(xs) xs[0] # ^^ reference local 1$2536404132 end +# ⌃ enclosing_range_end [..] C1#m4(). # Yet another.. # ...doc comment sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] C1#m5(). def m5 # ^^ definition [..] C1#m5(). # documentation @@ -96,12 +106,14 @@ def m5 # | ...doc comment true end +# ⌃ enclosing_range_end [..] C1#m5(). # And... # ...one more doc comment sig { params(C, T::Boolean).returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] C1#m6(). def m6(c, b) # ^^ definition [..] C1#m6(). # documentation @@ -126,8 +138,11 @@ def m6(c, b) # ^ reference local 1$2569959370 # ^ reference local 2$2569959370 end +# ⌃ enclosing_range_end [..] C1#m6(). end +# ⌃ enclosing_range_end [..] C1# +#⌄ enclosing_range_start [..] C2# class C2 # undocumented class # ^^ definition [..] C2# # documentation @@ -135,10 +150,12 @@ class C2 # undocumented class # | class C2 # | ``` end +# ⌃ enclosing_range_end [..] C2# # Module doc comment # # Some stuff +#⌄ enclosing_range_start [..] M1# module M1 # ^^ definition [..] M1# # documentation @@ -150,6 +167,7 @@ module M1 # | # | Some stuff # This class is nested inside M1 +# ⌄ enclosing_range_start [..] M1#C3# class C3 # ^^ definition [..] M1#C3# # documentation @@ -159,8 +177,10 @@ class C3 # documentation # | This class is nested inside M1 end +# ⌃ enclosing_range_end [..] M1#C3# # This module is nested inside M1 +# ⌄ enclosing_range_start [..] M1#M2# module M2 # ^^ definition [..] M1#M2# # documentation @@ -175,6 +195,7 @@ module M2 # This method is inside M1::M2 sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] M1#M2#n1(). def n1 # ^^ definition [..] M1#M2#n1(). # documentation @@ -186,8 +207,10 @@ def n1 # | This method is inside M1::M2 true end +# ⌃ enclosing_range_end [..] M1#M2#n1(). # This method is also inside M1::M2 +# ⌄ enclosing_range_start [..] M1#M2#n2(). def n2 # ^^ definition [..] M1#M2#n2(). # documentation @@ -198,10 +221,14 @@ def n2 # documentation # | This method is also inside M1::M2 end +# ⌃ enclosing_range_end [..] M1#M2#n2(). end +# ⌃ enclosing_range_end [..] M1#M2# end +# ⌃ enclosing_range_end [..] M1# # This is a global function +#⌄ enclosing_range_start [..] Object#f1(). def f1 # ^^ definition [..] Object#f1(). # documentation @@ -218,12 +245,14 @@ def f1 # ^^ reference [..] M1# # ^^ reference [..] M1#M2# end +# ⌃ enclosing_range_end [..] Object#f1(). # Yet another global function sig { returns(T::Integer) } #^^^ reference [..] Sorbet#Private#``#sig(). # ^^^^^^^ reference [..] T#Private#Methods#DeclBuilder#returns(). # ^ reference [..] T# +#⌄ enclosing_range_start [..] Object#f2(). def f2 # ^^ definition [..] Object#f2(). # documentation @@ -235,7 +264,9 @@ def f2 # | Yet another global function return 10 end +# ⌃ enclosing_range_end [..] Object#f2(). +#⌄ enclosing_range_start [..] Object#f3(). def f3 # undocumented global function # ^^ definition [..] Object#f3(). # documentation @@ -244,6 +275,7 @@ def f3 # undocumented global function # | def f3 # | ``` end +# ⌃ enclosing_range_end [..] Object#f3(). extend T::Sig #^^^^^^ reference [..] Kernel#extend(). @@ -254,6 +286,7 @@ def f3 # undocumented global function #^^^ reference [..] Sorbet#Private#``#sig(). # ^^^^^^^ reference [..] T#Private#Methods#DeclBuilder#returns(). # ^ reference [..] T# +#⌄ enclosing_range_start [..] Object#f4(). def f4 # another undocumented global function # ^^ definition [..] Object#f4(). # documentation @@ -263,8 +296,10 @@ def f4 # another undocumented global function # | ``` return 10 end +# ⌃ enclosing_range_end [..] Object#f4(). # Parent class +#⌄ enclosing_range_start [..] K1# class K1 # ^^ definition [..] K1# # documentation @@ -274,6 +309,7 @@ class K1 # documentation # | Parent class # sets @x and @@y +# ⌄ enclosing_range_start [..] K1#p1(). def p1 # ^^ definition [..] K1#p1(). # documentation @@ -297,8 +333,10 @@ def p1 # | @@y (Integer(10)) # | ``` end +# ⌃ enclosing_range_end [..] K1#p1(). # lorem ipsum, you get it +# ⌄ enclosing_range_start [..] ``#p2(). def self.p2 # ^^ definition [..] ``#p2(). # documentation @@ -316,9 +354,12 @@ def self.p2 # | @z (Integer(10)) # | ``` end +# ⌃ enclosing_range_end [..] ``#p2(). end +# ⌃ enclosing_range_end [..] K1# # Subclass +#⌄ enclosing_range_start [..] K2# class K2 < K1 # ^^ definition [..] K2# # documentation @@ -339,6 +380,7 @@ class K2 < K1 # | doc comment on class var ooh # overrides K1's p1 +# ⌄ enclosing_range_start [..] K2#p1(). def p1 # ^^ definition [..] K2#p1(). # documentation @@ -369,4 +411,6 @@ def p1 # | ``` # relation definition=[..] K1#`@x`. end +# ⌃ enclosing_range_end [..] K2#p1(). end +# ⌃ enclosing_range_end [..] K2# diff --git a/test/scip/testdata/implicit_super_arg.snapshot.rb b/test/scip/testdata/implicit_super_arg.snapshot.rb index 63af89ddb..2b084f1d5 100644 --- a/test/scip/testdata/implicit_super_arg.snapshot.rb +++ b/test/scip/testdata/implicit_super_arg.snapshot.rb @@ -18,12 +18,16 @@ # $6: Symbol(:) = : # $2: T.untyped = $4: T.class_of().(: C, $6: Symbol(:), : T.untyped, a: T.untyped, b: T.untyped) # : T.noreturn = return $2: T.untyped +#⌄ enclosing_range_start [..] C# class C # ^ definition [..] C# +# ⌄ enclosing_range_start [..] C#f(). def f(a, b) # ^ definition [..] C#f(). # ^ definition local 1$3809224601 # ^ definition local 2$3809224601 super end +# ⌃ enclosing_range_end [..] C#f(). end +# ⌃ enclosing_range_end [..] C# diff --git a/test/scip/testdata/inheritance.snapshot.rb b/test/scip/testdata/inheritance.snapshot.rb index dc51d5d52..d7518ea8e 100644 --- a/test/scip/testdata/inheritance.snapshot.rb +++ b/test/scip/testdata/inheritance.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Z1# class Z1 # ^^ definition [..] Z1# extend T::Sig @@ -7,6 +8,7 @@ class Z1 sig { params(a: T::Boolean).void } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] Z1#write_f(). def write_f(a) # ^^^^^^^ definition [..] Z1#write_f(). # ^ definition local 1$1000661517 @@ -15,16 +17,21 @@ def write_f(a) # ^^^^^^ reference [..] Z1#`@f`. # ^ reference local 1$1000661517 end +# ⌃ enclosing_range_end [..] Z1#write_f(). sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] Z1#`read_f?`(). def read_f? # ^^^^^^^ definition [..] Z1#`read_f?`(). @f # ^^ reference [..] Z1#`@f`. end +# ⌃ enclosing_range_end [..] Z1#`read_f?`(). end +# ⌃ enclosing_range_end [..] Z1# +#⌄ enclosing_range_start [..] Z2# class Z2 # ^^ definition [..] Z2# extend T::Sig @@ -32,14 +39,17 @@ class Z2 sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] Z2#`read_f?`(). def read_f? # ^^^^^^^ definition [..] Z2#`read_f?`(). @f # ^^ reference [..] Z2#`@f`. end +# ⌃ enclosing_range_end [..] Z2#`read_f?`(). sig { params(a: T::Boolean).void } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] Z2#write_f(). def write_f(a) # ^^^^^^^ definition [..] Z2#write_f(). # ^ definition local 1$1000661517 @@ -48,8 +58,11 @@ def write_f(a) # ^^^^^^ reference [..] Z2#`@f`. # ^ reference local 1$1000661517 end +# ⌃ enclosing_range_end [..] Z2#write_f(). end +# ⌃ enclosing_range_end [..] Z2# +#⌄ enclosing_range_start [..] Z3# class Z3 < Z1 # ^^ definition [..] Z3# # ^^ reference [..] Z1# @@ -58,14 +71,18 @@ class Z3 < Z1 sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] Z3#`read_f_plus_1?`(). def read_f_plus_1? # ^^^^^^^^^^^^^^ definition [..] Z3#`read_f_plus_1?`(). @f + 1 # ^^ reference [..] Z3#`@f`. # relation definition=[..] Z1#`@f`. end +# ⌃ enclosing_range_end [..] Z3#`read_f_plus_1?`(). end +# ⌃ enclosing_range_end [..] Z3# +#⌄ enclosing_range_start [..] Z4# class Z4 < Z3 # ^^ definition [..] Z4# # ^^ reference [..] Z3# @@ -74,6 +91,7 @@ class Z4 < Z3 sig { params(a: T::Boolean).void } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] Z4#write_f_plus_1(). def write_f_plus_1(a) # ^^^^^^^^^^^^^^ definition [..] Z4#write_f_plus_1(). # ^ definition local 1$3337417690 @@ -87,5 +105,7 @@ def write_f_plus_1(a) # relation definition=[..] Z1#`@f`. # ^^^^^^^^^^^^^^ reference [..] Z3#`read_f_plus_1?`(). end +# ⌃ enclosing_range_end [..] Z4#write_f_plus_1(). end +# ⌃ enclosing_range_end [..] Z4# diff --git a/test/scip/testdata/loops_and_conditionals.snapshot.rb b/test/scip/testdata/loops_and_conditionals.snapshot.rb index e6e78eefd..294d3d8e4 100644 --- a/test/scip/testdata/loops_and_conditionals.snapshot.rb +++ b/test/scip/testdata/loops_and_conditionals.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] Object#if_elsif_else(). def if_elsif_else() # ^^^^^^^^^^^^^ definition [..] Object#if_elsif_else(). x = 0 @@ -43,7 +44,9 @@ def if_elsif_else() return end +# ⌃ enclosing_range_end [..] Object#if_elsif_else(). +#⌄ enclosing_range_start [..] Object#unless(). def unless() # ^^^^^^ definition [..] Object#unless(). z = 0 @@ -66,7 +69,9 @@ def unless() end return end +# ⌃ enclosing_range_end [..] Object#unless(). +#⌄ enclosing_range_start [..] Object#case(). def case(x, y) # ^^^^ definition [..] Object#case(). # ^ definition local 1$2602907825 @@ -91,7 +96,9 @@ def case(x, y) end return end +# ⌃ enclosing_range_end [..] Object#case(). +#⌄ enclosing_range_start [..] Object#for(). def for(xs) # ^^^ definition [..] Object#for(). # ^^ definition local 1$2901640080 @@ -130,7 +137,9 @@ def for(xs) # ^^ reference [..] BasicObject#`==`(). end end +# ⌃ enclosing_range_end [..] Object#for(). +#⌄ enclosing_range_start [..] Object#while(). def while(xs) # ^^^^^ definition [..] Object#while(). # ^^ definition local 1$231090382 @@ -173,7 +182,9 @@ def while(xs) # ^^ reference [..] BasicObject#`==`(). end end +# ⌃ enclosing_range_end [..] Object#while(). +#⌄ enclosing_range_start [..] Object#until(). def until(xs) # ^^^^^ definition [..] Object#until(). # ^^ definition local 1$3132432719 @@ -216,7 +227,9 @@ def until(xs) # ^^ reference [..] BasicObject#`==`(). end end +# ⌃ enclosing_range_end [..] Object#until(). +#⌄ enclosing_range_start [..] Object#flip_flop(). def flip_flop(xs) # ^^^^^^^^^ definition [..] Object#flip_flop(). # ^^ definition local 1$2191960030 @@ -233,3 +246,4 @@ def flip_flop(xs) # ^ reference local 2$2191960030 end end +# ⌃ enclosing_range_end [..] Object#flip_flop(). diff --git a/test/scip/testdata/mattr.snapshot.rb b/test/scip/testdata/mattr.snapshot.rb index ad80c3a2c..c19c8a3e6 100644 --- a/test/scip/testdata/mattr.snapshot.rb +++ b/test/scip/testdata/mattr.snapshot.rb @@ -1,26 +1,43 @@ # typed: strict +#⌄ enclosing_range_start [..] MR# class MR # ^^ definition [..] MR# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] MR#both(). +# ⌄ enclosing_range_start [..] ``#both(). +# ⌄ enclosing_range_start [..] MR#foo(). +# ⌄ enclosing_range_start [..] ``#foo(). mattr_reader :both, :foo # ^^^^^ definition [..] MR#both(). # ^^^^^ definition [..] ``#both(). # ^^^^ definition [..] MR#foo(). # ^^^^ definition [..] ``#foo(). +# ⌃ enclosing_range_end [..] MR#both(). +# ⌃ enclosing_range_end [..] ``#both(). +# ⌃ enclosing_range_end [..] MR#foo(). +# ⌃ enclosing_range_end [..] ``#foo(). +# ⌄ enclosing_range_start [..] ``#no_instance(). mattr_reader :no_instance, instance_accessor: false # ^^^^^^^^^^^^ definition [..] ``#no_instance(). +# ⌃ enclosing_range_end [..] ``#no_instance(). +# ⌄ enclosing_range_start [..] ``#bar(). +# ⌄ enclosing_range_start [..] ``#no_instance_reader(). mattr_reader :bar, :no_instance_reader, instance_reader: false # ^^^^ definition [..] ``#bar(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#no_instance_reader(). +# ⌃ enclosing_range_end [..] ``#bar(). +# ⌃ enclosing_range_end [..] ``#no_instance_reader(). sig {void} +# ⌄ enclosing_range_start [..] MR#usages(). def usages # ^^^^^^ definition [..] MR#usages(). both # ^^^^ reference [..] MR#both(). end +# ⌃ enclosing_range_end [..] MR#usages(). both # ^^^^ reference [..] ``#both(). @@ -29,28 +46,46 @@ def usages no_instance_reader # ^^^^^^^^^^^^^^^^^^ reference [..] ``#no_instance_reader(). end +# ⌃ enclosing_range_end [..] MR# +#⌄ enclosing_range_start [..] MW# class MW # ^^ definition [..] MW# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] MW#`both=`(). +# ⌄ enclosing_range_start [..] ``#`both=`(). +# ⌄ enclosing_range_start [..] MW#`foo=`(). +# ⌄ enclosing_range_start [..] ``#`foo=`(). mattr_writer :both, :foo # ^^^^^ definition [..] MW#`both=`(). # ^^^^^ definition [..] ``#`both=`(). # ^^^^ definition [..] MW#`foo=`(). # ^^^^ definition [..] ``#`foo=`(). +# ⌃ enclosing_range_end [..] MW#`both=`(). +# ⌃ enclosing_range_end [..] ``#`both=`(). +# ⌃ enclosing_range_end [..] MW#`foo=`(). +# ⌃ enclosing_range_end [..] ``#`foo=`(). +# ⌄ enclosing_range_start [..] ``#`no_instance=`(). mattr_writer :no_instance, instance_accessor: false # ^^^^^^^^^^^^ definition [..] ``#`no_instance=`(). +# ⌃ enclosing_range_end [..] ``#`no_instance=`(). +# ⌄ enclosing_range_start [..] ``#`bar=`(). +# ⌄ enclosing_range_start [..] ``#`no_instance_writer=`(). mattr_writer :bar, :no_instance_writer, instance_writer: false # ^^^^ definition [..] ``#`bar=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#`no_instance_writer=`(). +# ⌃ enclosing_range_end [..] ``#`bar=`(). +# ⌃ enclosing_range_end [..] ``#`no_instance_writer=`(). sig {void} +# ⌄ enclosing_range_start [..] MW#usages(). def usages # ^^^^^^ definition [..] MW#usages(). self.both = 1 # ^^^^^^ reference [..] MW#`both=`(). end +# ⌃ enclosing_range_end [..] MW#usages(). self.both = 1 # ^^^^^^ reference [..] ``#`both=`(). @@ -59,11 +94,21 @@ def usages self.no_instance_writer = 1 # ^^^^^^^^^^^^^^^^^^^^ reference [..] ``#`no_instance_writer=`(). end +# ⌃ enclosing_range_end [..] MW# +#⌄ enclosing_range_start [..] MA# class MA # ^^ definition [..] MA# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] MA#`both=`(). +# ⌄ enclosing_range_start [..] MA#both(). +# ⌄ enclosing_range_start [..] ``#`both=`(). +# ⌄ enclosing_range_start [..] ``#both(). +# ⌄ enclosing_range_start [..] MA#`foo=`(). +# ⌄ enclosing_range_start [..] MA#foo(). +# ⌄ enclosing_range_start [..] ``#`foo=`(). +# ⌄ enclosing_range_start [..] ``#foo(). mattr_accessor :both, :foo # ^^^^^ definition [..] MA#both(). # ^^^^^ definition [..] MA#`both=`(). @@ -73,13 +118,37 @@ class MA # ^^^^ definition [..] MA#foo(). # ^^^^ definition [..] ``#`foo=`(). # ^^^^ definition [..] ``#foo(). +# ⌃ enclosing_range_end [..] MA#`both=`(). +# ⌃ enclosing_range_end [..] MA#both(). +# ⌃ enclosing_range_end [..] ``#`both=`(). +# ⌃ enclosing_range_end [..] ``#both(). +# ⌃ enclosing_range_end [..] MA#`foo=`(). +# ⌃ enclosing_range_end [..] MA#foo(). +# ⌃ enclosing_range_end [..] ``#`foo=`(). +# ⌃ enclosing_range_end [..] ``#foo(). +# ⌄ enclosing_range_start [..] ``#`no_instance=`(). +# ⌄ enclosing_range_start [..] ``#no_instance(). mattr_accessor :no_instance, instance_accessor: false # ^^^^^^^^^^^^ definition [..] ``#`no_instance=`(). # ^^^^^^^^^^^^ definition [..] ``#no_instance(). +# ⌃ enclosing_range_end [..] ``#`no_instance=`(). +# ⌃ enclosing_range_end [..] ``#no_instance(). +# ⌄ enclosing_range_start [..] MA#`no_instance_reader=`(). +# ⌄ enclosing_range_start [..] ``#`no_instance_reader=`(). +# ⌄ enclosing_range_start [..] ``#no_instance_reader(). mattr_accessor :no_instance_reader, instance_reader: false # ^^^^^^^^^^^^^^^^^^^ definition [..] MA#`no_instance_reader=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#`no_instance_reader=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#no_instance_reader(). +# ⌃ enclosing_range_end [..] MA#`no_instance_reader=`(). +# ⌃ enclosing_range_end [..] ``#`no_instance_reader=`(). +# ⌃ enclosing_range_end [..] ``#no_instance_reader(). +# ⌄ enclosing_range_start [..] MA#bar(). +# ⌄ enclosing_range_start [..] ``#`bar=`(). +# ⌄ enclosing_range_start [..] ``#bar(). +# ⌄ enclosing_range_start [..] MA#no_instance_writer(). +# ⌄ enclosing_range_start [..] ``#`no_instance_writer=`(). +# ⌄ enclosing_range_start [..] ``#no_instance_writer(). mattr_accessor :bar, :no_instance_writer, instance_writer: false # ^^^^ definition [..] MA#bar(). # ^^^^ definition [..] ``#`bar=`(). @@ -87,8 +156,15 @@ class MA # ^^^^^^^^^^^^^^^^^^^ definition [..] MA#no_instance_writer(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#`no_instance_writer=`(). # ^^^^^^^^^^^^^^^^^^^ definition [..] ``#no_instance_writer(). +# ⌃ enclosing_range_end [..] MA#bar(). +# ⌃ enclosing_range_end [..] ``#`bar=`(). +# ⌃ enclosing_range_end [..] ``#bar(). +# ⌃ enclosing_range_end [..] MA#no_instance_writer(). +# ⌃ enclosing_range_end [..] ``#`no_instance_writer=`(). +# ⌃ enclosing_range_end [..] ``#no_instance_writer(). sig {void} +# ⌄ enclosing_range_start [..] MA#usages(). def usages # ^^^^^^ definition [..] MA#usages(). both @@ -102,6 +178,7 @@ def usages no_instance_writer # ^^^^^^^^^^^^^^^^^^ reference [..] MA#no_instance_writer(). end +# ⌃ enclosing_range_end [..] MA#usages(). both # ^^^^ reference [..] ``#both(). @@ -123,3 +200,4 @@ def usages self.no_instance_writer = 1 # ^^^^^^^^^^^^^^^^^^^^ reference [..] ``#`no_instance_writer=`(). end +# ⌃ enclosing_range_end [..] MA# diff --git a/test/scip/testdata/metaprog.snapshot.rb b/test/scip/testdata/metaprog.snapshot.rb index 485758575..27475d561 100644 --- a/test/scip/testdata/metaprog.snapshot.rb +++ b/test/scip/testdata/metaprog.snapshot.rb @@ -4,6 +4,7 @@ # indexer (define_method body is a normal block; method_missing / respond_to_missing? # are normal method defs). +#⌄ enclosing_range_start [..] Dynamo# class Dynamo # ^^^^^^ definition [..] Dynamo# define_method(:dynamic) do |x| @@ -13,6 +14,7 @@ class Dynamo # ^ reference local 1$119448696 end +# ⌄ enclosing_range_start [..] Dynamo#method_missing(). def method_missing(name, *args, &blk) # ^^^^^^^^^^^^^^ definition [..] Dynamo#method_missing(). # ^^^^ definition local 1$2090704463 @@ -20,13 +22,18 @@ def method_missing(name, *args, &blk) # ^^^^ reference local 1$2090704463 # ^^^^ reference [..] Kernel#to_s(). end +# ⌃ enclosing_range_end [..] Dynamo#method_missing(). +# ⌄ enclosing_range_start [..] Dynamo#`respond_to_missing?`(). def respond_to_missing?(name, include_private = false) # ^^^^^^^^^^^^^^^^^^^ definition [..] Dynamo#`respond_to_missing?`(). true end +# ⌃ enclosing_range_end [..] Dynamo#`respond_to_missing?`(). end +# ⌃ enclosing_range_end [..] Dynamo# +#⌄ enclosing_range_start [..] Object#use_meta(). def use_meta # ^^^^^^^^ definition [..] Object#use_meta(). Dynamo.new.dynamic(1) @@ -36,3 +43,4 @@ def use_meta # ^^^^^^ reference [..] Dynamo# # ^^^ reference [..] Class#new(). end +# ⌃ enclosing_range_end [..] Object#use_meta(). diff --git a/test/scip/testdata/method_inheritance.snapshot.rb b/test/scip/testdata/method_inheritance.snapshot.rb index 2aea57918..7bf589471 100644 --- a/test/scip/testdata/method_inheritance.snapshot.rb +++ b/test/scip/testdata/method_inheritance.snapshot.rb @@ -1,22 +1,32 @@ # typed: true +#⌄ enclosing_range_start [..] C1# class C1 # ^^ definition [..] C1# +# ⌄ enclosing_range_start [..] C1#m1(). def m1 # ^^ definition [..] C1#m1(). end +# ⌃ enclosing_range_end [..] C1#m1(). +# ⌄ enclosing_range_start [..] C1#m2(). def m2 # ^^ definition [..] C1#m2(). end +# ⌃ enclosing_range_end [..] C1#m2(). end +# ⌃ enclosing_range_end [..] C1# +#⌄ enclosing_range_start [..] C2# class C2 < C1 # ^^ definition [..] C2# # ^^ reference [..] C1# +# ⌄ enclosing_range_start [..] C2#m2(). def m2 # ^^ definition [..] C2#m2(). end +# ⌃ enclosing_range_end [..] C2#m2(). +# ⌄ enclosing_range_start [..] C2#m3(). def m3 # ^^ definition [..] C2#m3(). m1 @@ -24,14 +34,20 @@ def m3 m2 # ^^ reference [..] C2#m2(). end +# ⌃ enclosing_range_end [..] C2#m3(). end +# ⌃ enclosing_range_end [..] C2# +#⌄ enclosing_range_start [..] C3# class C3 < C2 # ^^ definition [..] C3# # ^^ reference [..] C2# +# ⌄ enclosing_range_start [..] C3#m4(). def m4 # ^^ definition [..] C3#m4(). m1 # ^^ reference [..] C1#m1(). end +# ⌃ enclosing_range_end [..] C3#m4(). end +# ⌃ enclosing_range_end [..] C3# diff --git a/test/scip/testdata/minitest_1.snapshot.rb b/test/scip/testdata/minitest_1.snapshot.rb index 1da6a4949..94870ad32 100644 --- a/test/scip/testdata/minitest_1.snapshot.rb +++ b/test/scip/testdata/minitest_1.snapshot.rb @@ -1,10 +1,14 @@ # typed: true +#⌄ enclosing_range_start [..] MyTest# class MyTest # ^^^^^^ definition [..] MyTest# +# ⌄ enclosing_range_start [..] MyTest#outside_method(). def outside_method # ^^^^^^^^^^^^^^ definition [..] MyTest#outside_method(). end +# ⌃ enclosing_range_end [..] MyTest#outside_method(). +# ⌄ enclosing_range_start [..] MyTest#``(). it "works outside" do # ^^^^^^^^^^^^^^^ definition [..] MyTest#``(). x = outside_method @@ -15,7 +19,9 @@ def outside_method # ^ reference local 1$1914741329 return end +# ⌃ enclosing_range_end [..] MyTest#``(). +# ⌄ enclosing_range_start [..] MyTest#``(). it "allows constants inside of IT" do # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#``(). CONST = 10 @@ -24,7 +30,9 @@ def outside_method # ^^^^^^^^^^ reference [..] Kernel#raise(). # ^^^^^^^^^^ reference [..] Module# end +# ⌃ enclosing_range_end [..] MyTest#``(). +# ⌄ enclosing_range_start [..] MyTest#``(). it "allows let-ed constants inside of IT" do # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#``(). C2 = T.let(10, Integer) @@ -36,7 +44,9 @@ def outside_method # ^^^^^^^ definition local 3$119448696 # ^^^^^^^ reference [..] Integer# end +# ⌃ enclosing_range_end [..] MyTest#``(). +# ⌄ enclosing_range_start [..] MyTest#``(). it "allows path constants inside of IT" do # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#``(). C3 = Mod::C @@ -48,14 +58,19 @@ def outside_method # ^^ reference [..] MyTest#C3. # ^^^ reference [..] Class#new(). end +# ⌃ enclosing_range_end [..] MyTest#``(). +# ⌄ enclosing_range_start [..] MyTest#``# describe "some inner tests" do # ^^^^^^^^^^^^^^^^^^ reference [..] MyTest# # ^^^^^^^^^^^^^^^^^^ definition [..] MyTest#``# +# ⌄ enclosing_range_start [..] MyTest#``#inside_method(). def inside_method # ^^^^^^^^^^^^^ definition [..] MyTest#``#inside_method(). end +# ⌃ enclosing_range_end [..] MyTest#``#inside_method(). +# ⌄ enclosing_range_start [..] MyTest#``#``(). it "works inside" do # ^^^^^^^^^^^^^^ definition [..] MyTest#``#``(). outside_method @@ -63,11 +78,16 @@ def inside_method inside_method # ^^^^^^^^^^^^^ reference [..] MyTest#``#inside_method(). end +# ⌃ enclosing_range_end [..] MyTest#``#``(). end +# ⌃ enclosing_range_end [..] MyTest#``# +# ⌄ enclosing_range_start [..] MyTest#instance_helper(). def instance_helper; end # ^^^^^^^^^^^^^^^ definition [..] MyTest#instance_helper(). +# ⌃ enclosing_range_end [..] MyTest#instance_helper(). +# ⌄ enclosing_range_start [..] MyTest#``(). before do # ^^^^^^ definition [..] MyTest#``(). @foo = T.let(3, Integer) @@ -77,7 +97,9 @@ def instance_helper; end instance_helper # ^^^^^^^^^^^^^^^ reference [..] MyTest#instance_helper(). end +# ⌃ enclosing_range_end [..] MyTest#``(). +# ⌄ enclosing_range_start [..] MyTest#``(). it 'can read foo' do # ^^^^^^^^^^^^^^ definition [..] MyTest#``(). T.assert_type!(@foo, Integer) @@ -87,27 +109,38 @@ def instance_helper; end instance_helper # ^^^^^^^^^^^^^^^ reference [..] MyTest#instance_helper(). end +# ⌃ enclosing_range_end [..] MyTest#``(). +# ⌄ enclosing_range_start [..] ``#random_method(). def self.random_method # ^^^^^^^^^^^^^ definition [..] ``#random_method(). end +# ⌃ enclosing_range_end [..] ``#random_method(). +# ⌄ enclosing_range_start [..] MyTest#``# describe Object do # ^^^^^^ reference [..] MyTest# # ^^^^^^ definition [..] MyTest#``# +# ⌄ enclosing_range_start [..] MyTest#``#``(). it Object do # ^^^^^^ definition [..] MyTest#``#``(). # ^^^^^^ definition [..] MyTest#``#``(). # ^^^^^^ reference [..] Object# end +# ⌃ enclosing_range_end [..] MyTest#``#``(). +# ⌄ enclosing_range_start [..] MyTest#``#``(). it Object do # ^^^^^^ reference [..] Object# end +# ⌃ enclosing_range_end [..] MyTest#``#``(). end +# ⌃ enclosing_range_end [..] MyTest#``# +# ⌄ enclosing_range_start [..] ``#it(). def self.it(*args) # ^^ definition [..] ``#it(). end +# ⌃ enclosing_range_end [..] ``#it(). it "ignores methods without a block" # ^^ reference [..] ``#it(). @@ -117,27 +150,40 @@ def self.it(*args) # ^^^^ reference [..] Object#junk(). end +# ⌄ enclosing_range_start [..] MyTest#``# describe "a non-ideal situation" do # ^^^^^^^^^^^^^^^^^^^^^^^ reference [..] MyTest# # ^^^^^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#``# +# ⌄ enclosing_range_start [..] MyTest#``#``(). it "contains nested describes" do # ^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#``#``(). +# ⌄ enclosing_range_start [..] MyTest#``#``# describe "nobody should write this but we should still parse it" do # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] MyTest#``# # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#``#``# end +# ⌃ enclosing_range_end [..] MyTest#``#``# end +# ⌃ enclosing_range_end [..] MyTest#``#``(). end +# ⌃ enclosing_range_end [..] MyTest#``# end +# ⌃ enclosing_range_end [..] MyTest# +#⌄ enclosing_range_start [..] Object#junk(). def junk # ^^^^ definition [..] Object#junk(). end +# ⌃ enclosing_range_end [..] Object#junk(). +#⌄ enclosing_range_start [..] Mod# module Mod # ^^^ definition [..] Mod# +# ⌄ enclosing_range_start [..] Mod#C# class C # ^ definition [..] Mod#C# end +# ⌃ enclosing_range_end [..] Mod#C# end +# ⌃ enclosing_range_end [..] Mod# diff --git a/test/scip/testdata/minitest_2.snapshot.rb b/test/scip/testdata/minitest_2.snapshot.rb index 6040bb350..3cdd479e3 100644 --- a/test/scip/testdata/minitest_2.snapshot.rb +++ b/test/scip/testdata/minitest_2.snapshot.rb @@ -1,17 +1,26 @@ # typed: true +#⌄ enclosing_range_start [..] Test# class Test # ^^^^ definition [..] Test# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] ``#test_each(). def self.test_each(arg, &blk); end # ^^^^^^^^^ definition [..] ``#test_each(). +# ⌃ enclosing_range_end [..] ``#test_each(). +# ⌄ enclosing_range_start [..] ``#it(). def self.it(name, &blk); end # ^^ definition [..] ``#it(). +# ⌃ enclosing_range_end [..] ``#it(). +# ⌄ enclosing_range_start [..] ``#describe(). def self.describe(name, &blk); end # ^^^^^^^^ definition [..] ``#describe(). +# ⌃ enclosing_range_end [..] ``#describe(). end +# ⌃ enclosing_range_end [..] Test# +#⌄ enclosing_range_start [..] Foo# class Foo < Test # ^^^ definition [..] Foo# # ^^^^ reference [..] Test# @@ -20,11 +29,16 @@ class Foo < Test # ^^^^^^^^^ reference [..] ``#test_each(). # ^^ error: Hint: this "do" token +# ⌄ enclosing_range_start [..] Foo#``(). it "it block 1" do # ^^^^^^^^^^^^ definition [..] Foo#``(). end +# ⌃ enclosing_range_end [..] Foo#``(). +# ⌄ enclosing_range_start [..] Foo#``(). it "it block 2" do # ^^^^^^^^^^^^ definition [..] Foo#``(). end +# ⌃ enclosing_range_end [..] Foo#``(). end # error: unexpected token "end of file" +# ⌃ enclosing_range_end [..] Foo# diff --git a/test/scip/testdata/minitest_3.snapshot.rb b/test/scip/testdata/minitest_3.snapshot.rb index ae29d923e..a26e444ba 100644 --- a/test/scip/testdata/minitest_3.snapshot.rb +++ b/test/scip/testdata/minitest_3.snapshot.rb @@ -4,17 +4,24 @@ # ^ reference [..] T# # ^^^ reference [..] T#Sig# +#⌄ enclosing_range_start [..] Test# class Test # ^^^^ definition [..] Test# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). +# ⌄ enclosing_range_start [..] ``#test_each(). def self.test_each(iter, &blk); end # ^^^^^^^^^ definition [..] ``#test_each(). +# ⌃ enclosing_range_end [..] ``#test_each(). +# ⌄ enclosing_range_start [..] ``#it(). def self.it(name, &blk); end # ^^ definition [..] ``#it(). +# ⌃ enclosing_range_end [..] ``#it(). +# ⌄ enclosing_range_start [..] ``#describe(). def self.describe(name, &blk); end # ^^^^^^^^ definition [..] ``#describe(). +# ⌃ enclosing_range_end [..] ``#describe(). test_each([[1,2], [3,4]]) do |(a,b)| # ^^^^^^^^^ reference [..] ``#test_each(). @@ -24,6 +31,7 @@ def self.describe(name, &blk); end # ^ definition local 2$416088458 describe "d" do +# ⌄ enclosing_range_start [..] Test#``(). it "b" do # ^^^ definition [..] Test#``(). T.reveal_type(a) # error: Revealed type: `Integer` @@ -31,8 +39,10 @@ def self.describe(name, &blk); end # ^^^^^^^^^^^ reference [..] ``#reveal_type(). # ^ reference local 1$416088458 end +# ⌃ enclosing_range_end [..] Test#``(). end +# ⌄ enclosing_range_start [..] Test#``(). it "a" do # ^^^ definition [..] Test#``(). T.reveal_type(a) # error: Revealed type: `Integer` @@ -40,6 +50,8 @@ def self.describe(name, &blk); end # ^^^^^^^^^^^ reference [..] ``#reveal_type(). # ^ reference local 1$2288740619 end +# ⌃ enclosing_range_end [..] Test#``(). end end +# ⌃ enclosing_range_end [..] Test# diff --git a/test/scip/testdata/mixin.snapshot.rb b/test/scip/testdata/mixin.snapshot.rb index 4ee65c05d..6c3560aac 100644 --- a/test/scip/testdata/mixin.snapshot.rb +++ b/test/scip/testdata/mixin.snapshot.rb @@ -1,29 +1,40 @@ # typed: true +#⌄ enclosing_range_start [..] M# module M # ^ definition [..] M# +# ⌄ enclosing_range_start [..] M#f(). def f; puts 'M.f'; end # ^ definition [..] M#f(). +# ⌃ enclosing_range_end [..] M#f(). end +# ⌃ enclosing_range_end [..] M# +#⌄ enclosing_range_start [..] C1# class C1 # ^^ definition [..] C1# include M # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] M# # ^ reference [..] M# +# ⌄ enclosing_range_start [..] C1#f(). def f; puts 'C1.f'; end # ^ definition [..] C1#f(). # ^^^^ reference [..] Kernel#puts(). +# ⌃ enclosing_range_end [..] C1#f(). end +# ⌃ enclosing_range_end [..] C1# # f refers to C1.f +#⌄ enclosing_range_start [..] C2# class C2 < C1 # ^^ definition [..] C2# # ^^ reference [..] C1# end +# ⌃ enclosing_range_end [..] C2# # f refers to C1.f +#⌄ enclosing_range_start [..] C3# class C3 < C1 # ^^ definition [..] C3# # ^^ reference [..] C1# @@ -32,14 +43,20 @@ class C3 < C1 # ^ reference [..] M# # ^ reference [..] M# end +# ⌃ enclosing_range_end [..] C3# +#⌄ enclosing_range_start [..] D1# class D1 # ^^ definition [..] D1# +# ⌄ enclosing_range_start [..] D1#f(). def f; puts 'D1.f'; end # ^ definition [..] D1#f(). # ^^^^ reference [..] Kernel#puts(). +# ⌃ enclosing_range_end [..] D1#f(). end +# ⌃ enclosing_range_end [..] D1# +#⌄ enclosing_range_start [..] D2# class D2 # ^^ definition [..] D2# include M @@ -47,6 +64,7 @@ class D2 # ^ reference [..] M# # ^ reference [..] M# end +# ⌃ enclosing_range_end [..] D2# C1.new.f # C1.f #^^ reference [..] C1# @@ -72,45 +90,63 @@ class D2 # Definition in directly included module and Self +#⌄ enclosing_range_start [..] T0# module T0 # ^^ definition [..] T0# +# ⌄ enclosing_range_start [..] T0#M# module M # ^ definition [..] T0#M# +# ⌄ enclosing_range_start [..] T0#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T0#M#set_f_0(). # ^^ definition [..] T0#M#`@f`. # ^^^^^^ reference [..] T0#M#`@f`. +# ⌃ enclosing_range_end [..] T0#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T0#M# +# ⌄ enclosing_range_start [..] T0#C# class C # ^ definition [..] T0#C# include M # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T0#M# # ^ reference [..] T0#M# +# ⌄ enclosing_range_start [..] T0#C#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T0#C#set_f_1(). # ^^ definition [..] T0#C#`@f`. # relation reference=[..] T0#M#`@f`. # ^^^^^^ reference [..] T0#C#`@f`. +# ⌃ enclosing_range_end [..] T0#C#set_f_1(). +# ⌄ enclosing_range_start [..] T0#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T0#C#get_f(). # ^^ reference [..] T0#C#`@f`. +# ⌃ enclosing_range_end [..] T0#C#get_f(). end +# ⌃ enclosing_range_end [..] T0#C# end +# ⌃ enclosing_range_end [..] T0# # Definition in transitively included module and Self +#⌄ enclosing_range_start [..] T1# module T1 # ^^ definition [..] T1# +# ⌄ enclosing_range_start [..] T1#M0# module M0 # ^^ definition [..] T1#M0# +# ⌄ enclosing_range_start [..] T1#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T1#M0#set_f_0(). # ^^ definition [..] T1#M0#`@f`. # ^^^^^^ reference [..] T1#M0#`@f`. +# ⌃ enclosing_range_end [..] T1#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T1#M0# +# ⌄ enclosing_range_start [..] T1#M1# module M1 # ^^ definition [..] T1#M1# include M0 @@ -118,60 +154,84 @@ module M1 # ^^ reference [..] T1#M0# # ^^ reference [..] T1#M0# end +# ⌃ enclosing_range_end [..] T1#M1# +# ⌄ enclosing_range_start [..] T1#C# class C # ^ definition [..] T1#C# include M1 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T1#M1# # ^^ reference [..] T1#M1# +# ⌄ enclosing_range_start [..] T1#C#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T1#C#set_f_1(). # ^^ definition [..] T1#C#`@f`. # relation reference=[..] T1#M0#`@f`. # ^^^^^^ reference [..] T1#C#`@f`. +# ⌃ enclosing_range_end [..] T1#C#set_f_1(). +# ⌄ enclosing_range_start [..] T1#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T1#C#get_f(). # ^^ reference [..] T1#C#`@f`. +# ⌃ enclosing_range_end [..] T1#C#get_f(). end +# ⌃ enclosing_range_end [..] T1#C# end +# ⌃ enclosing_range_end [..] T1# # Definition in directly included module only +#⌄ enclosing_range_start [..] T2# module T2 # ^^ definition [..] T2# +# ⌄ enclosing_range_start [..] T2#M# module M # ^ definition [..] T2#M# +# ⌄ enclosing_range_start [..] T2#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T2#M#set_f_0(). # ^^ definition [..] T2#M#`@f`. # ^^^^^^ reference [..] T2#M#`@f`. +# ⌃ enclosing_range_end [..] T2#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T2#M# +# ⌄ enclosing_range_start [..] T2#C# class C # ^ definition [..] T2#C# include M # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T2#M# # ^ reference [..] T2#M# +# ⌄ enclosing_range_start [..] T2#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T2#C#get_f(). # ^^ reference [..] T2#C#`@f`. +# ⌃ enclosing_range_end [..] T2#C#get_f(). end +# ⌃ enclosing_range_end [..] T2#C# end +# ⌃ enclosing_range_end [..] T2# # Definition in transitively included module only +#⌄ enclosing_range_start [..] T3# module T3 # ^^ definition [..] T3# +# ⌄ enclosing_range_start [..] T3#M0# module M0 # ^^ definition [..] T3#M0# +# ⌄ enclosing_range_start [..] T3#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T3#M0#set_f_0(). # ^^ definition [..] T3#M0#`@f`. # ^^^^^^ reference [..] T3#M0#`@f`. +# ⌃ enclosing_range_end [..] T3#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T3#M0# +# ⌄ enclosing_range_start [..] T3#M1# module M1 # ^^ definition [..] T3#M1# include M0 @@ -179,39 +239,55 @@ module M1 # ^^ reference [..] T3#M0# # ^^ reference [..] T3#M0# end +# ⌃ enclosing_range_end [..] T3#M1# +# ⌄ enclosing_range_start [..] T3#C# class C # ^ definition [..] T3#C# include M1 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T3#M1# # ^^ reference [..] T3#M1# +# ⌄ enclosing_range_start [..] T3#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T3#C#get_f(). # ^^ reference [..] T3#C#`@f`. +# ⌃ enclosing_range_end [..] T3#C#get_f(). end +# ⌃ enclosing_range_end [..] T3#C# end +# ⌃ enclosing_range_end [..] T3# # Definition in directly included module & superclass & Self +#⌄ enclosing_range_start [..] T4# module T4 # ^^ definition [..] T4# +# ⌄ enclosing_range_start [..] T4#M# module M # ^ definition [..] T4#M# +# ⌄ enclosing_range_start [..] T4#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T4#M#set_f_0(). # ^^ definition [..] T4#M#`@f`. # ^^^^^^ reference [..] T4#M#`@f`. +# ⌃ enclosing_range_end [..] T4#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T4#M# +# ⌄ enclosing_range_start [..] T4#C0# class C0 # ^^ definition [..] T4#C0# +# ⌄ enclosing_range_start [..] T4#C0#set_f_2(). def set_f_2; @f = 2; end # ^^^^^^^ definition [..] T4#C0#set_f_2(). # ^^ definition [..] T4#C0#`@f`. # ^^^^^^ reference [..] T4#C0#`@f`. +# ⌃ enclosing_range_end [..] T4#C0#set_f_2(). end +# ⌃ enclosing_range_end [..] T4#C0# +# ⌄ enclosing_range_start [..] T4#C1# class C1 < C0 # ^^ definition [..] T4#C1# # ^^ reference [..] T4#C0# @@ -219,31 +295,43 @@ class C1 < C0 # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T4#M# # ^ reference [..] T4#M# +# ⌄ enclosing_range_start [..] T4#C1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T4#C1#set_f_1(). # ^^ definition [..] T4#C1#`@f`. # relation definition=[..] T4#C0#`@f`. reference=[..] T4#M#`@f`. # ^^^^^^ reference [..] T4#C1#`@f`. # relation definition=[..] T4#C0#`@f`. reference=[..] T4#M#`@f`. +# ⌃ enclosing_range_end [..] T4#C1#set_f_1(). +# ⌄ enclosing_range_start [..] T4#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T4#C1#get_f(). # ^^ reference [..] T4#C1#`@f`. # relation definition=[..] T4#C0#`@f`. reference=[..] T4#M#`@f`. +# ⌃ enclosing_range_end [..] T4#C1#get_f(). end +# ⌃ enclosing_range_end [..] T4#C1# end +# ⌃ enclosing_range_end [..] T4# # Definition in transitively included module & superclass & Self +#⌄ enclosing_range_start [..] T5# module T5 # ^^ definition [..] T5# +# ⌄ enclosing_range_start [..] T5#M0# module M0 # ^^ definition [..] T5#M0# +# ⌄ enclosing_range_start [..] T5#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T5#M0#set_f_0(). # ^^ definition [..] T5#M0#`@f`. # ^^^^^^ reference [..] T5#M0#`@f`. +# ⌃ enclosing_range_end [..] T5#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T5#M0# +# ⌄ enclosing_range_start [..] T5#M1# module M1 # ^^ definition [..] T5#M1# include M0 @@ -251,15 +339,21 @@ module M1 # ^^ reference [..] T5#M0# # ^^ reference [..] T5#M0# end +# ⌃ enclosing_range_end [..] T5#M1# +# ⌄ enclosing_range_start [..] T5#C0# class C0 # ^^ definition [..] T5#C0# +# ⌄ enclosing_range_start [..] T5#C0#set_f_2(). def set_f_2; @f = 2; end # ^^^^^^^ definition [..] T5#C0#set_f_2(). # ^^ definition [..] T5#C0#`@f`. # ^^^^^^ reference [..] T5#C0#`@f`. +# ⌃ enclosing_range_end [..] T5#C0#set_f_2(). end +# ⌃ enclosing_range_end [..] T5#C0# +# ⌄ enclosing_range_start [..] T5#C1# class C1 < C0 # ^^ definition [..] T5#C1# # ^^ reference [..] T5#C0# @@ -267,61 +361,87 @@ class C1 < C0 # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] M# # ^ reference [..] M# +# ⌄ enclosing_range_start [..] T5#C1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T5#C1#set_f_1(). # ^^ definition [..] T5#C1#`@f`. # relation definition=[..] T5#C0#`@f`. # ^^^^^^ reference [..] T5#C1#`@f`. # relation definition=[..] T5#C0#`@f`. +# ⌃ enclosing_range_end [..] T5#C1#set_f_1(). +# ⌄ enclosing_range_start [..] T5#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T5#C1#get_f(). # ^^ reference [..] T5#C1#`@f`. # relation definition=[..] T5#C0#`@f`. +# ⌃ enclosing_range_end [..] T5#C1#get_f(). end +# ⌃ enclosing_range_end [..] T5#C1# end +# ⌃ enclosing_range_end [..] T5# # Definition in directly included module & superclass only +#⌄ enclosing_range_start [..] T6# module T6 # ^^ definition [..] T6# +# ⌄ enclosing_range_start [..] T6#M# module M # ^ definition [..] T6#M# +# ⌄ enclosing_range_start [..] T6#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T6#M#set_f_0(). # ^^ definition [..] T6#M#`@f`. # ^^^^^^ reference [..] T6#M#`@f`. +# ⌃ enclosing_range_end [..] T6#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T6#M# +# ⌄ enclosing_range_start [..] T6#C0# class C0 # ^^ definition [..] T6#C0# +# ⌄ enclosing_range_start [..] T6#C0#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T6#C0#set_f_1(). # ^^ definition [..] T6#C0#`@f`. # ^^^^^^ reference [..] T6#C0#`@f`. +# ⌃ enclosing_range_end [..] T6#C0#set_f_1(). end +# ⌃ enclosing_range_end [..] T6#C0# +# ⌄ enclosing_range_start [..] T6#C1# class C1 < C0 # ^^ definition [..] T6#C1# # ^^ reference [..] T6#C0# +# ⌄ enclosing_range_start [..] T6#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T6#C1#get_f(). # ^^ reference [..] T6#C1#`@f`. # relation definition=[..] T6#C0#`@f`. +# ⌃ enclosing_range_end [..] T6#C1#get_f(). end +# ⌃ enclosing_range_end [..] T6#C1# end +# ⌃ enclosing_range_end [..] T6# # Definition in transitively included module & superclass only +#⌄ enclosing_range_start [..] T7# module T7 # ^^ definition [..] T7# +# ⌄ enclosing_range_start [..] T7#M0# module M0 # ^^ definition [..] T7#M0# +# ⌄ enclosing_range_start [..] T7#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T7#M0#set_f_0(). # ^^ definition [..] T7#M0#`@f`. # ^^^^^^ reference [..] T7#M0#`@f`. +# ⌃ enclosing_range_end [..] T7#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T7#M0# +# ⌄ enclosing_range_start [..] T7#M1# module M1 # ^^ definition [..] T7#M1# include M0 @@ -329,113 +449,159 @@ module M1 # ^^ reference [..] T7#M0# # ^^ reference [..] T7#M0# end +# ⌃ enclosing_range_end [..] T7#M1# +# ⌄ enclosing_range_start [..] T7#C0# class C0 # ^^ definition [..] T7#C0# +# ⌄ enclosing_range_start [..] T7#C0#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T7#C0#set_f_1(). # ^^ definition [..] T7#C0#`@f`. # ^^^^^^ reference [..] T7#C0#`@f`. +# ⌃ enclosing_range_end [..] T7#C0#set_f_1(). end +# ⌃ enclosing_range_end [..] T7#C0# +# ⌄ enclosing_range_start [..] T7#C1# class C1 < C0 # ^^ definition [..] T7#C1# # ^^ reference [..] T7#C0# +# ⌄ enclosing_range_start [..] T7#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T7#C1#get_f(). # ^^ reference [..] T7#C1#`@f`. # relation definition=[..] T7#C0#`@f`. +# ⌃ enclosing_range_end [..] T7#C1#get_f(). end +# ⌃ enclosing_range_end [..] T7#C1# end +# ⌃ enclosing_range_end [..] T7# # Definition in module included via superclass & superclass & Self +#⌄ enclosing_range_start [..] T8# module T8 # ^^ definition [..] T8# +# ⌄ enclosing_range_start [..] T8#M# module M # ^ definition [..] T8#M# +# ⌄ enclosing_range_start [..] T8#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T8#M#set_f_0(). # ^^ definition [..] T8#M#`@f`. # ^^^^^^ reference [..] T8#M#`@f`. +# ⌃ enclosing_range_end [..] T8#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T8#M# +# ⌄ enclosing_range_start [..] T8#C0# class C0 # ^^ definition [..] T8#C0# include M # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T8#M# # ^ reference [..] T8#M# +# ⌄ enclosing_range_start [..] T8#C0#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T8#C0#set_f_1(). # ^^ definition [..] T8#C0#`@f`. # relation reference=[..] T8#M#`@f`. # ^^^^^^ reference [..] T8#C0#`@f`. +# ⌃ enclosing_range_end [..] T8#C0#set_f_1(). end +# ⌃ enclosing_range_end [..] T8#C0# +# ⌄ enclosing_range_start [..] T8#C1# class C1 < C0 # ^^ definition [..] T8#C1# # ^^ reference [..] T8#C0# +# ⌄ enclosing_range_start [..] T8#C1#set_f_2(). def set_f_2; @f = 2; end # ^^^^^^^ definition [..] T8#C1#set_f_2(). # ^^ definition [..] T8#C1#`@f`. # relation definition=[..] T8#C0#`@f`. # ^^^^^^ reference [..] T8#C1#`@f`. # relation definition=[..] T8#C0#`@f`. +# ⌃ enclosing_range_end [..] T8#C1#set_f_2(). +# ⌄ enclosing_range_start [..] T8#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T8#C1#get_f(). # ^^ reference [..] T8#C1#`@f`. # relation definition=[..] T8#C0#`@f`. +# ⌃ enclosing_range_end [..] T8#C1#get_f(). end +# ⌃ enclosing_range_end [..] T8#C1# end +# ⌃ enclosing_range_end [..] T8# # Definition in module included via superclass & superclass only +#⌄ enclosing_range_start [..] T9# module T9 # ^^ definition [..] T9# +# ⌄ enclosing_range_start [..] T9#M# module M # ^ definition [..] T9#M# +# ⌄ enclosing_range_start [..] T9#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T9#M#set_f_0(). # ^^ definition [..] T9#M#`@f`. # ^^^^^^ reference [..] T9#M#`@f`. +# ⌃ enclosing_range_end [..] T9#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T9#M# +# ⌄ enclosing_range_start [..] T9#C0# class C0 # ^^ definition [..] T9#C0# include M # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T9#M# # ^ reference [..] T9#M# +# ⌄ enclosing_range_start [..] T9#C0#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T9#C0#set_f_1(). # ^^ definition [..] T9#C0#`@f`. # relation reference=[..] T9#M#`@f`. # ^^^^^^ reference [..] T9#C0#`@f`. +# ⌃ enclosing_range_end [..] T9#C0#set_f_1(). end +# ⌃ enclosing_range_end [..] T9#C0# +# ⌄ enclosing_range_start [..] T9#C1# class C1 < C0 # ^^ definition [..] T9#C1# # ^^ reference [..] T9#C0# +# ⌄ enclosing_range_start [..] T9#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T9#C1#get_f(). # ^^ reference [..] T9#C1#`@f`. # relation definition=[..] T9#C0#`@f`. +# ⌃ enclosing_range_end [..] T9#C1#get_f(). end +# ⌃ enclosing_range_end [..] T9#C1# end +# ⌃ enclosing_range_end [..] T9# # Definition in module included via superclass & Self +#⌄ enclosing_range_start [..] T10# module T10 # ^^^ definition [..] T10# +# ⌄ enclosing_range_start [..] T10#M# module M # ^ definition [..] T10#M# +# ⌄ enclosing_range_start [..] T10#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T10#M#set_f_0(). # ^^ definition [..] T10#M#`@f`. # ^^^^^^ reference [..] T10#M#`@f`. +# ⌃ enclosing_range_end [..] T10#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T10#M# +# ⌄ enclosing_range_start [..] T10#C0# class C0 # ^^ definition [..] T10#C0# include M @@ -443,32 +609,46 @@ class C0 # ^ reference [..] T10#M# # ^ reference [..] T10#M# end +# ⌃ enclosing_range_end [..] T10#C0# +# ⌄ enclosing_range_start [..] T10#C1# class C1 < C0 # ^^ definition [..] T10#C1# # ^^ reference [..] T10#C0# +# ⌄ enclosing_range_start [..] T10#C1#set_f_2(). def set_f_2; @f = 2; end # ^^^^^^^ definition [..] T10#C1#set_f_2(). # ^^ definition [..] T10#C1#`@f`. # ^^^^^^ reference [..] T10#C1#`@f`. +# ⌃ enclosing_range_end [..] T10#C1#set_f_2(). +# ⌄ enclosing_range_start [..] T10#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T10#C1#get_f(). # ^^ reference [..] T10#C1#`@f`. +# ⌃ enclosing_range_end [..] T10#C1#get_f(). end +# ⌃ enclosing_range_end [..] T10#C1# end +# ⌃ enclosing_range_end [..] T10# # Definition in module included via superclass only +#⌄ enclosing_range_start [..] T11# module T11 # ^^^ definition [..] T11# +# ⌄ enclosing_range_start [..] T11#M# module M # ^ definition [..] T11#M# +# ⌄ enclosing_range_start [..] T11#M#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T11#M#set_f_0(). # ^^ definition [..] T11#M#`@f`. # ^^^^^^ reference [..] T11#M#`@f`. +# ⌃ enclosing_range_end [..] T11#M#set_f_0(). end +# ⌃ enclosing_range_end [..] T11#M# +# ⌄ enclosing_range_start [..] T11#C0# class C0 # ^^ definition [..] T11#C0# include M @@ -476,36 +656,52 @@ class C0 # ^ reference [..] T11#M# # ^ reference [..] T11#M# end +# ⌃ enclosing_range_end [..] T11#C0# +# ⌄ enclosing_range_start [..] T11#C1# class C1 < C0 # ^^ definition [..] T11#C1# # ^^ reference [..] T11#C0# +# ⌄ enclosing_range_start [..] T11#C1#get_f(). def get_f; @f; end # ^^^^^ definition [..] T11#C1#get_f(). # ^^ reference [..] T11#C1#`@f`. +# ⌃ enclosing_range_end [..] T11#C1#get_f(). end +# ⌃ enclosing_range_end [..] T11#C1# end +# ⌃ enclosing_range_end [..] T11# # Definition in multiple transitively included modules & common child & Self +#⌄ enclosing_range_start [..] T12# module T12 # ^^^ definition [..] T12# +# ⌄ enclosing_range_start [..] T12#M0# module M0 # ^^ definition [..] T12#M0# +# ⌄ enclosing_range_start [..] T12#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T12#M0#set_f_0(). # ^^ definition [..] T12#M0#`@f`. # ^^^^^^ reference [..] T12#M0#`@f`. +# ⌃ enclosing_range_end [..] T12#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T12#M0# +# ⌄ enclosing_range_start [..] T12#M1# module M1 # ^^ definition [..] T12#M1# +# ⌄ enclosing_range_start [..] T12#M1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T12#M1#set_f_1(). # ^^ definition [..] T12#M1#`@f`. # ^^^^^^ reference [..] T12#M1#`@f`. +# ⌃ enclosing_range_end [..] T12#M1#set_f_1(). end +# ⌃ enclosing_range_end [..] T12#M1# +# ⌄ enclosing_range_start [..] T12#M2# module M2 # ^^ definition [..] T12#M2# include M0 @@ -516,50 +712,70 @@ module M2 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T12#M1# # ^^ reference [..] T12#M1# +# ⌄ enclosing_range_start [..] T12#M2#set_f_2(). def set_f_2; @f = 2; end # ^^^^^^^ definition [..] T12#M2#set_f_2(). # ^^ definition [..] T12#M2#`@f`. # relation reference=[..] T12#M0#`@f`. reference=[..] T12#M1#`@f`. # ^^^^^^ reference [..] T12#M2#`@f`. +# ⌃ enclosing_range_end [..] T12#M2#set_f_2(). end +# ⌃ enclosing_range_end [..] T12#M2# +# ⌄ enclosing_range_start [..] T12#C# class C # ^ definition [..] T12#C# include M2 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T12#M2# # ^^ reference [..] T12#M2# +# ⌄ enclosing_range_start [..] T12#C#set_f_3(). def set_f_3; @f = 3; end # ^^^^^^^ definition [..] T12#C#set_f_3(). # ^^ definition [..] T12#C#`@f`. # relation reference=[..] T12#M0#`@f`. reference=[..] T12#M1#`@f`. reference=[..] T12#M2#`@f`. # ^^^^^^ reference [..] T12#C#`@f`. +# ⌃ enclosing_range_end [..] T12#C#set_f_3(). +# ⌄ enclosing_range_start [..] T12#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T12#C#get_f(). # ^^ reference [..] T12#C#`@f`. +# ⌃ enclosing_range_end [..] T12#C#get_f(). end +# ⌃ enclosing_range_end [..] T12#C# end +# ⌃ enclosing_range_end [..] T12# # Definition in multiple transitively included modules & common child only +#⌄ enclosing_range_start [..] T13# module T13 # ^^^ definition [..] T13# +# ⌄ enclosing_range_start [..] T13#M0# module M0 # ^^ definition [..] T13#M0# +# ⌄ enclosing_range_start [..] T13#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T13#M0#set_f_0(). # ^^ definition [..] T13#M0#`@f`. # ^^^^^^ reference [..] T13#M0#`@f`. +# ⌃ enclosing_range_end [..] T13#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T13#M0# +# ⌄ enclosing_range_start [..] T13#M1# module M1 # ^^ definition [..] T13#M1# +# ⌄ enclosing_range_start [..] T13#M1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T13#M1#set_f_1(). # ^^ definition [..] T13#M1#`@f`. # ^^^^^^ reference [..] T13#M1#`@f`. +# ⌃ enclosing_range_end [..] T13#M1#set_f_1(). end +# ⌃ enclosing_range_end [..] T13#M1# +# ⌄ enclosing_range_start [..] T13#M2# module M2 # ^^ definition [..] T13#M2# include M0 @@ -570,45 +786,63 @@ module M2 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T13#M1# # ^^ reference [..] T13#M1# +# ⌄ enclosing_range_start [..] T13#M2#set_f_2(). def set_f_2; @f = 2; end # ^^^^^^^ definition [..] T13#M2#set_f_2(). # ^^ definition [..] T13#M2#`@f`. # relation reference=[..] T13#M0#`@f`. reference=[..] T13#M1#`@f`. # ^^^^^^ reference [..] T13#M2#`@f`. +# ⌃ enclosing_range_end [..] T13#M2#set_f_2(). end +# ⌃ enclosing_range_end [..] T13#M2# +# ⌄ enclosing_range_start [..] T13#C# class C # ^ definition [..] T13#C# include M2 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T13#M2# # ^^ reference [..] T13#M2# +# ⌄ enclosing_range_start [..] T13#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T13#C#get_f(). # ^^ reference [..] T13#C#`@f`. +# ⌃ enclosing_range_end [..] T13#C#get_f(). end +# ⌃ enclosing_range_end [..] T13#C# end +# ⌃ enclosing_range_end [..] T13# # Definition in multiple transitively included modules & Self +#⌄ enclosing_range_start [..] T14# module T14 # ^^^ definition [..] T14# +# ⌄ enclosing_range_start [..] T14#M0# module M0 # ^^ definition [..] T14#M0# +# ⌄ enclosing_range_start [..] T14#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T14#M0#set_f_0(). # ^^ definition [..] T14#M0#`@f`. # ^^^^^^ reference [..] T14#M0#`@f`. +# ⌃ enclosing_range_end [..] T14#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T14#M0# +# ⌄ enclosing_range_start [..] T14#M1# module M1 # ^^ definition [..] T14#M1# +# ⌄ enclosing_range_start [..] T14#M1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T14#M1#set_f_1(). # ^^ definition [..] T14#M1#`@f`. # ^^^^^^ reference [..] T14#M1#`@f`. +# ⌃ enclosing_range_end [..] T14#M1#set_f_1(). end +# ⌃ enclosing_range_end [..] T14#M1# +# ⌄ enclosing_range_start [..] T14#M2# module M2 # ^^ definition [..] T14#M2# include M0 @@ -620,44 +854,62 @@ module M2 # ^^ reference [..] T14#M1# # ^^ reference [..] T14#M1# end +# ⌃ enclosing_range_end [..] T14#M2# +# ⌄ enclosing_range_start [..] T14#C# class C # ^ definition [..] T14#C# include M2 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T14#M2# # ^^ reference [..] T14#M2# +# ⌄ enclosing_range_start [..] T14#C#set_f_3(). def set_f_3; @f = 3; end # ^^^^^^^ definition [..] T14#C#set_f_3(). # ^^ definition [..] T14#C#`@f`. # relation reference=[..] T14#M0#`@f`. reference=[..] T14#M1#`@f`. # ^^^^^^ reference [..] T14#C#`@f`. +# ⌃ enclosing_range_end [..] T14#C#set_f_3(). +# ⌄ enclosing_range_start [..] T14#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T14#C#get_f(). # ^^ reference [..] T14#C#`@f`. +# ⌃ enclosing_range_end [..] T14#C#get_f(). end +# ⌃ enclosing_range_end [..] T14#C# end +# ⌃ enclosing_range_end [..] T14# # Definition in multiple transitively included modules only +#⌄ enclosing_range_start [..] T15# module T15 # ^^^ definition [..] T15# +# ⌄ enclosing_range_start [..] T15#M0# module M0 # ^^ definition [..] T15#M0# +# ⌄ enclosing_range_start [..] T15#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T15#M0#set_f_0(). # ^^ definition [..] T15#M0#`@f`. # ^^^^^^ reference [..] T15#M0#`@f`. +# ⌃ enclosing_range_end [..] T15#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T15#M0# +# ⌄ enclosing_range_start [..] T15#M1# module M1 # ^^ definition [..] T15#M1# +# ⌄ enclosing_range_start [..] T15#M1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T15#M1#set_f_1(). # ^^ definition [..] T15#M1#`@f`. # ^^^^^^ reference [..] T15#M1#`@f`. +# ⌃ enclosing_range_end [..] T15#M1#set_f_1(). end +# ⌃ enclosing_range_end [..] T15#M1# +# ⌄ enclosing_range_start [..] T15#M2# module M2 # ^^ definition [..] T15#M2# include M0 @@ -669,39 +921,55 @@ module M2 # ^^ reference [..] T15#M1# # ^^ reference [..] T15#M1# end +# ⌃ enclosing_range_end [..] T15#M2# +# ⌄ enclosing_range_start [..] T15#C# class C # ^ definition [..] T15#C# include M2 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T15#M2# # ^^ reference [..] T15#M2# +# ⌄ enclosing_range_start [..] T15#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T15#C#get_f(). # ^^ reference [..] T15#C#`@f`. +# ⌃ enclosing_range_end [..] T15#C#get_f(). end +# ⌃ enclosing_range_end [..] T15#C# end +# ⌃ enclosing_range_end [..] T15# # Definition in multiple directly included modules & Self +#⌄ enclosing_range_start [..] T16# module T16 # ^^^ definition [..] T16# +# ⌄ enclosing_range_start [..] T16#M0# module M0 # ^^ definition [..] T16#M0# +# ⌄ enclosing_range_start [..] T16#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T16#M0#set_f_0(). # ^^ definition [..] T16#M0#`@f`. # ^^^^^^ reference [..] T16#M0#`@f`. +# ⌃ enclosing_range_end [..] T16#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T16#M0# +# ⌄ enclosing_range_start [..] T16#M1# module M1 # ^^ definition [..] T16#M1# +# ⌄ enclosing_range_start [..] T16#M1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T16#M1#set_f_1(). # ^^ definition [..] T16#M1#`@f`. # ^^^^^^ reference [..] T16#M1#`@f`. +# ⌃ enclosing_range_end [..] T16#M1#set_f_1(). end +# ⌃ enclosing_range_end [..] T16#M1# +# ⌄ enclosing_range_start [..] T16#C# class C # ^ definition [..] T16#C# include M0 @@ -712,37 +980,53 @@ class C # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T16#M1# # ^^ reference [..] T16#M1# +# ⌄ enclosing_range_start [..] T16#C#set_f_2(). def set_f_2; @f = 2; end # ^^^^^^^ definition [..] T16#C#set_f_2(). # ^^ definition [..] T16#C#`@f`. # relation reference=[..] T16#M0#`@f`. reference=[..] T16#M1#`@f`. # ^^^^^^ reference [..] T16#C#`@f`. +# ⌃ enclosing_range_end [..] T16#C#set_f_2(). +# ⌄ enclosing_range_start [..] T16#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T16#C#get_f(). # ^^ reference [..] T16#C#`@f`. +# ⌃ enclosing_range_end [..] T16#C#get_f(). end +# ⌃ enclosing_range_end [..] T16#C# end +# ⌃ enclosing_range_end [..] T16# # Definition in multiple directly included modules only +#⌄ enclosing_range_start [..] T17# module T17 # ^^^ definition [..] T17# +# ⌄ enclosing_range_start [..] T17#M0# module M0 # ^^ definition [..] T17#M0# +# ⌄ enclosing_range_start [..] T17#M0#set_f_0(). def set_f_0; @f = 0; end # ^^^^^^^ definition [..] T17#M0#set_f_0(). # ^^ definition [..] T17#M0#`@f`. # ^^^^^^ reference [..] T17#M0#`@f`. +# ⌃ enclosing_range_end [..] T17#M0#set_f_0(). end +# ⌃ enclosing_range_end [..] T17#M0# +# ⌄ enclosing_range_start [..] T17#M1# module M1 # ^^ definition [..] T17#M1# +# ⌄ enclosing_range_start [..] T17#M1#set_f_1(). def set_f_1; @f = 1; end # ^^^^^^^ definition [..] T17#M1#set_f_1(). # ^^ definition [..] T17#M1#`@f`. # ^^^^^^ reference [..] T17#M1#`@f`. +# ⌃ enclosing_range_end [..] T17#M1#set_f_1(). end +# ⌃ enclosing_range_end [..] T17#M1# +# ⌄ enclosing_range_start [..] T17#C# class C # ^ definition [..] T17#C# include M0 @@ -753,11 +1037,15 @@ class C # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] T17#M1# # ^^ reference [..] T17#M1# +# ⌄ enclosing_range_start [..] T17#C#get_f(). def get_f; @f; end # ^^^^^ definition [..] T17#C#get_f(). # ^^ reference [..] T17#C#`@f`. +# ⌃ enclosing_range_end [..] T17#C#get_f(). end +# ⌃ enclosing_range_end [..] T17#C# end +# ⌃ enclosing_range_end [..] T17# # OKAY! Now for the more "weird" situations # Before this, all the tests had a definition come "before" use. @@ -765,40 +1053,56 @@ def get_f; @f; end # Reference in directly included module with def in Self +#⌄ enclosing_range_start [..] W0# module W0 # ^^ definition [..] W0# +# ⌄ enclosing_range_start [..] W0#M# module M # ^ definition [..] W0#M# +# ⌄ enclosing_range_start [..] W0#M#get_f(). def get_f; @f; end # ^^^^^ definition [..] W0#M#get_f(). # ^^ reference [..] W0#M#`@f`. +# ⌃ enclosing_range_end [..] W0#M#get_f(). end +# ⌃ enclosing_range_end [..] W0#M# +# ⌄ enclosing_range_start [..] W0#C# class C # ^ definition [..] W0#C# include M # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] W0#M# # ^ reference [..] W0#M# +# ⌄ enclosing_range_start [..] W0#C#set_f(). def set_f; @f = 0; end # ^^^^^ definition [..] W0#C#set_f(). # ^^ definition [..] W0#C#`@f`. # relation reference=[..] W0#M#`@f`. # ^^^^^^ reference [..] W0#C#`@f`. +# ⌃ enclosing_range_end [..] W0#C#set_f(). end +# ⌃ enclosing_range_end [..] W0#C# end +# ⌃ enclosing_range_end [..] W0# # Reference in transitively included module with def in Self +#⌄ enclosing_range_start [..] W1# module W1 # ^^ definition [..] W1# +# ⌄ enclosing_range_start [..] W1#M0# module M0 # ^^ definition [..] W1#M0# +# ⌄ enclosing_range_start [..] W1#M0#get_f(). def get_f; @f; end # ^^^^^ definition [..] W1#M0#get_f(). # ^^ reference [..] W1#M0#`@f`. +# ⌃ enclosing_range_end [..] W1#M0#get_f(). end +# ⌃ enclosing_range_end [..] W1#M0# +# ⌄ enclosing_range_start [..] W1#M1# module M1 # ^^ definition [..] W1#M1# include M0 @@ -806,40 +1110,56 @@ module M1 # ^^ reference [..] W1#M0# # ^^ reference [..] W1#M0# end +# ⌃ enclosing_range_end [..] W1#M1# +# ⌄ enclosing_range_start [..] W1#C# class C # ^ definition [..] W1#C# include M1 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] W1#M1# # ^^ reference [..] W1#M1# +# ⌄ enclosing_range_start [..] W1#C#set_f(). def set_f; @f = 0; end # ^^^^^ definition [..] W1#C#set_f(). # ^^ definition [..] W1#C#`@f`. # relation reference=[..] W1#M0#`@f`. # ^^^^^^ reference [..] W1#C#`@f`. +# ⌃ enclosing_range_end [..] W1#C#set_f(). end +# ⌃ enclosing_range_end [..] W1#C# end +# ⌃ enclosing_range_end [..] W1# # Reference in superclass with def in directly included module +#⌄ enclosing_range_start [..] W2# module W2 # ^^ definition [..] W2# +# ⌄ enclosing_range_start [..] W2#M# module M # ^ definition [..] W2#M# +# ⌄ enclosing_range_start [..] W2#M#set_f(). def set_f; @f = 0; end # ^^^^^ definition [..] W2#M#set_f(). # ^^ definition [..] W2#M#`@f`. # ^^^^^^ reference [..] W2#M#`@f`. +# ⌃ enclosing_range_end [..] W2#M#set_f(). end +# ⌃ enclosing_range_end [..] W2#M# +# ⌄ enclosing_range_start [..] W2#C0# class C0 # ^^ definition [..] W2#C0# +# ⌄ enclosing_range_start [..] W2#C0#get_f(). def get_f; @f; end # ^^^^^ definition [..] W2#C0#get_f(). # ^^ reference [..] W2#C0#`@f`. +# ⌃ enclosing_range_end [..] W2#C0#get_f(). end +# ⌃ enclosing_range_end [..] W2#C0# +# ⌄ enclosing_range_start [..] W2#C1# class C1 < C0 # ^^ definition [..] W2#C1# # ^^ reference [..] W2#C0# @@ -847,32 +1167,46 @@ class C1 < C0 # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] W2#M# # ^ reference [..] W2#M# +# ⌄ enclosing_range_start [..] W2#C1#get_fp1(). def get_fp1; @f + 1; end # ^^^^^^^ definition [..] W2#C1#get_fp1(). # ^^ reference [..] W2#C1#`@f`. # relation definition=[..] W2#C0#`@f`. reference=[..] W2#M#`@f`. +# ⌃ enclosing_range_end [..] W2#C1#get_fp1(). end +# ⌃ enclosing_range_end [..] W2#C1# end +# ⌃ enclosing_range_end [..] W2# # Reference in directly included module with def in superclass +#⌄ enclosing_range_start [..] W3# module W3 # ^^ definition [..] W3# +# ⌄ enclosing_range_start [..] W3#M# module M # ^ definition [..] W3#M# +# ⌄ enclosing_range_start [..] W3#M#get_f(). def get_f; @f; end # ^^^^^ definition [..] W3#M#get_f(). # ^^ reference [..] W3#M#`@f`. +# ⌃ enclosing_range_end [..] W3#M#get_f(). end +# ⌃ enclosing_range_end [..] W3#M# +# ⌄ enclosing_range_start [..] W3#C0# class C0 # ^^ definition [..] W3#C0# +# ⌄ enclosing_range_start [..] W3#C0#set_f(). def set_f; @f = 0; end # ^^^^^ definition [..] W3#C0#set_f(). # ^^ definition [..] W3#C0#`@f`. # ^^^^^^ reference [..] W3#C0#`@f`. +# ⌃ enclosing_range_end [..] W3#C0#set_f(). end +# ⌃ enclosing_range_end [..] W3#C0# +# ⌄ enclosing_range_start [..] W3#C1# class C1 < C0 # ^^ definition [..] W3#C1# # ^^ reference [..] W3#C0# @@ -880,67 +1214,95 @@ class C1 < C0 # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] W3#M# # ^ reference [..] W3#M# +# ⌄ enclosing_range_start [..] W3#C1#get_fp1(). def get_fp1; @f + 1; end # ^^^^^^^ definition [..] W3#C1#get_fp1(). # ^^ reference [..] W3#C1#`@f`. # relation definition=[..] W3#C0#`@f`. reference=[..] W3#M#`@f`. +# ⌃ enclosing_range_end [..] W3#C1#get_fp1(). end +# ⌃ enclosing_range_end [..] W3#C1# end +# ⌃ enclosing_range_end [..] W3# # Reference in transitively included module with def in in-between module +#⌄ enclosing_range_start [..] W4# module W4 # ^^ definition [..] W4# +# ⌄ enclosing_range_start [..] W4#M0# module M0 # ^^ definition [..] W4#M0# +# ⌄ enclosing_range_start [..] W4#M0#get_f(). def get_f; @f; end # ^^^^^ definition [..] W4#M0#get_f(). # ^^ reference [..] W4#M0#`@f`. +# ⌃ enclosing_range_end [..] W4#M0#get_f(). end +# ⌃ enclosing_range_end [..] W4#M0# +# ⌄ enclosing_range_start [..] W4#M1# module M1 # ^^ definition [..] W4#M1# include M0 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] W4#M0# # ^^ reference [..] W4#M0# +# ⌄ enclosing_range_start [..] W4#M1#set_f(). def set_f; @f = 0; end # ^^^^^ definition [..] W4#M1#set_f(). # ^^ definition [..] W4#M1#`@f`. # relation reference=[..] W4#M0#`@f`. # ^^^^^^ reference [..] W4#M1#`@f`. +# ⌃ enclosing_range_end [..] W4#M1#set_f(). end +# ⌃ enclosing_range_end [..] W4#M1# +# ⌄ enclosing_range_start [..] W4#C# class C # ^ definition [..] W4#C# include M1 # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] W4#M1# # ^^ reference [..] W4#M1# +# ⌄ enclosing_range_start [..] W4#C#get_fp1(). def get_fp1; @f + 1; end # ^^^^^^^ definition [..] W4#C#get_fp1(). # ^^ reference [..] W4#C#`@f`. +# ⌃ enclosing_range_end [..] W4#C#get_fp1(). end +# ⌃ enclosing_range_end [..] W4#C# end +# ⌃ enclosing_range_end [..] W4# # Reference in one directly included module with def in other directly included module +#⌄ enclosing_range_start [..] W5# module W5 # ^^ definition [..] W5# +# ⌄ enclosing_range_start [..] W5#M0# module M0 # ^^ definition [..] W5#M0# +# ⌄ enclosing_range_start [..] W5#M0#get_f(). def get_f; @f; end # ^^^^^ definition [..] W5#M0#get_f(). # ^^ reference [..] W5#M0#`@f`. +# ⌃ enclosing_range_end [..] W5#M0#get_f(). end +# ⌃ enclosing_range_end [..] W5#M0# +# ⌄ enclosing_range_start [..] W5#M1# module M1 # ^^ definition [..] W5#M1# +# ⌄ enclosing_range_start [..] W5#M1#set_f(). def set_f; @f + 1; end # ^^^^^ definition [..] W5#M1#set_f(). # ^^ reference [..] W5#M1#`@f`. +# ⌃ enclosing_range_end [..] W5#M1#set_f(). end +# ⌃ enclosing_range_end [..] W5#M1# +# ⌄ enclosing_range_start [..] W5#C# class C # ^ definition [..] W5#C# include M0 @@ -951,8 +1313,12 @@ class C # ^^^^^^^ reference [..] Module#include(). # ^^ reference [..] W5#M1# # ^^ reference [..] W5#M1# +# ⌄ enclosing_range_start [..] W5#C#get_fp1(). def get_fp1; @f + 1; end # ^^^^^^^ definition [..] W5#C#get_fp1(). # ^^ reference [..] W5#C#`@f`. +# ⌃ enclosing_range_end [..] W5#C#get_fp1(). end +# ⌃ enclosing_range_end [..] W5#C# end +# ⌃ enclosing_range_end [..] W5# diff --git a/test/scip/testdata/module_function.snapshot.rb b/test/scip/testdata/module_function.snapshot.rb index 2379b31e5..5dc717285 100644 --- a/test/scip/testdata/module_function.snapshot.rb +++ b/test/scip/testdata/module_function.snapshot.rb @@ -1,14 +1,20 @@ # typed: true +#⌄ enclosing_range_start [..] M# module M # ^ definition [..] M# sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] M#b(). def b # ^ definition [..] M#b(). true end +# ⌃ enclosing_range_end [..] M#b(). +# ⌄ enclosing_range_start [..] ``#b(). module_function :b # ^^ definition [..] ``#b(). +# ⌃ enclosing_range_end [..] ``#b(). end +# ⌃ enclosing_range_end [..] M# diff --git a/test/scip/testdata/multifile/basic/def_class1.snapshot.rb b/test/scip/testdata/multifile/basic/def_class1.snapshot.rb index 16c892df6..648743ed0 100644 --- a/test/scip/testdata/multifile/basic/def_class1.snapshot.rb +++ b/test/scip/testdata/multifile/basic/def_class1.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] C1# class C1 # ^^ definition [..] C1# extend T::Sig @@ -7,8 +8,11 @@ class C1 sig { returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] C1#m1(). def m1 # ^^ definition [..] C1#m1(). true end +# ⌃ enclosing_range_end [..] C1#m1(). end +# ⌃ enclosing_range_end [..] C1# diff --git a/test/scip/testdata/multifile/gem-map/current.snapshot.rb b/test/scip/testdata/multifile/gem-map/current.snapshot.rb index 364a9650b..c005671e7 100644 --- a/test/scip/testdata/multifile/gem-map/current.snapshot.rb +++ b/test/scip/testdata/multifile/gem-map/current.snapshot.rb @@ -7,6 +7,7 @@ # File missing from gem map; check fallback behavior +#⌄ enclosing_range_start my_current_gem 2 Object#h(). def h() # ^ definition my_current_gem 2 Object#h(). f() @@ -14,3 +15,4 @@ def h() g() # ^ reference my_upstream_gem 1 Object#g(). end +# ⌃ enclosing_range_end my_current_gem 2 Object#h(). diff --git a/test/scip/testdata/multifile/gem-map/downstream.snapshot.rb b/test/scip/testdata/multifile/gem-map/downstream.snapshot.rb index 303ffee6c..9421c51cd 100644 --- a/test/scip/testdata/multifile/gem-map/downstream.snapshot.rb +++ b/test/scip/testdata/multifile/gem-map/downstream.snapshot.rb @@ -3,8 +3,10 @@ require 'upstream' #^^^^^^^ reference [..] Kernel#require(). +#⌄ enclosing_range_start my_downstream_gem 1 Object#f(). def f() # ^ definition my_downstream_gem 1 Object#f(). g() # ^ reference my_upstream_gem 1 Object#g(). end +# ⌃ enclosing_range_end my_downstream_gem 1 Object#f(). diff --git a/test/scip/testdata/multifile/gem-map/upstream.snapshot.rb b/test/scip/testdata/multifile/gem-map/upstream.snapshot.rb index bbd3ebc72..8df21ef40 100644 --- a/test/scip/testdata/multifile/gem-map/upstream.snapshot.rb +++ b/test/scip/testdata/multifile/gem-map/upstream.snapshot.rb @@ -1,7 +1,9 @@ # typed: true +#⌄ enclosing_range_start my_upstream_gem 1 Object#g(). def g() # ^ definition my_upstream_gem 1 Object#g(). puts 'Hello' # ^^^^ reference [..] Kernel#puts(). end +# ⌃ enclosing_range_end my_upstream_gem 1 Object#g(). diff --git a/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rb b/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rb index 465299164..567018e00 100644 --- a/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rb +++ b/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rb @@ -1,9 +1,13 @@ # typed: true +#⌄ enclosing_range_start currentgem 77 CurrentGem# module CurrentGem # ^^^^^^^^^^ definition currentgem 77 CurrentGem# +# ⌄ enclosing_range_start currentgem 77 CurrentGem#gem_fun(). def gem_fun # ^^^^^^^ definition currentgem 77 CurrentGem#gem_fun(). puts 'Hello World' end +# ⌃ enclosing_range_end currentgem 77 CurrentGem#gem_fun(). end +# ⌃ enclosing_range_end currentgem 77 CurrentGem# diff --git a/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rbi b/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rbi index 59cca356c..f2e1eec6d 100644 --- a/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rbi +++ b/test/scip/testdata/multifile/infer-gem-map/current_gem.snapshot.rbi @@ -1,7 +1,11 @@ # typed: true +#⌄ enclosing_range_start currentgem 77 CurrentGem# module CurrentGem # ^^^^^^^^^^ definition currentgem 77 CurrentGem# +# ⌄ enclosing_range_start currentgem 77 CurrentGem#gem_fun(). def gem_fun; end # ^^^^^^^ definition currentgem 77 CurrentGem#gem_fun(). +# ⌃ enclosing_range_end currentgem 77 CurrentGem#gem_fun(). end +# ⌃ enclosing_range_end currentgem 77 CurrentGem# diff --git a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/annotations/annotgem.snapshot.rbi b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/annotations/annotgem.snapshot.rbi index d9a52306a..3423bfdc3 100644 --- a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/annotations/annotgem.snapshot.rbi +++ b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/annotations/annotgem.snapshot.rbi @@ -1,7 +1,11 @@ # typed: true +#⌄ enclosing_range_start annotgem latest AnnotGem# module AnnotGem # ^^^^^^^^ definition annotgem latest AnnotGem# +# ⌄ enclosing_range_start annotgem latest AnnotGem#annot_fun(). def annot_fun; end # ^^^^^^^^^ definition annotgem latest AnnotGem#annot_fun(). +# ⌃ enclosing_range_end annotgem latest AnnotGem#annot_fun(). end +# ⌃ enclosing_range_end annotgem latest AnnotGem# diff --git a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/dsl/railsgem.snapshot.rbi b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/dsl/railsgem.snapshot.rbi index 0e760635a..2e3f3c67c 100644 --- a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/dsl/railsgem.snapshot.rbi +++ b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/dsl/railsgem.snapshot.rbi @@ -1,7 +1,11 @@ # typed: true +#⌄ enclosing_range_start railsgem latest DSLGem# module DSLGem # ^^^^^^ definition railsgem latest DSLGem# +# ⌄ enclosing_range_start railsgem latest DSLGem#create(). def create; end # ^^^^^^ definition railsgem latest DSLGem#create(). +# ⌃ enclosing_range_end railsgem latest DSLGem#create(). end +# ⌃ enclosing_range_end railsgem latest DSLGem# diff --git a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/gems/extgem@99.snapshot.rbi b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/gems/extgem@99.snapshot.rbi index e91677376..43e733ce0 100644 --- a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/gems/extgem@99.snapshot.rbi +++ b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/gems/extgem@99.snapshot.rbi @@ -1,7 +1,11 @@ # typed: true +#⌄ enclosing_range_start extgem 99 ExternalGem# module ExternalGem # ^^^^^^^^^^^ definition extgem 99 ExternalGem# +# ⌄ enclosing_range_start extgem 99 ExternalGem#ext_fun(). def ext_fun; end # ^^^^^^^ definition extgem 99 ExternalGem#ext_fun(). +# ⌃ enclosing_range_end extgem 99 ExternalGem#ext_fun(). end +# ⌃ enclosing_range_end extgem 99 ExternalGem# diff --git a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/hidden-definitions/hidden.snapshot.rbi b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/hidden-definitions/hidden.snapshot.rbi index e88989fa7..2fafaf0ea 100644 --- a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/hidden-definitions/hidden.snapshot.rbi +++ b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/hidden-definitions/hidden.snapshot.rbi @@ -1,7 +1,11 @@ # typed: true +#⌄ enclosing_range_start currentgem 77 Hidden# module Hidden # ^^^^^^ definition currentgem 77 Hidden# +# ⌄ enclosing_range_start currentgem 77 Hidden#hidden_fun(). def hidden_fun; end # ^^^^^^^^^^ definition currentgem 77 Hidden#hidden_fun(). +# ⌃ enclosing_range_end currentgem 77 Hidden#hidden_fun(). end +# ⌃ enclosing_range_end currentgem 77 Hidden# diff --git a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/todo.snapshot.rbi b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/todo.snapshot.rbi index 0b9070ad3..6e1619d12 100644 --- a/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/todo.snapshot.rbi +++ b/test/scip/testdata/multifile/infer-gem-map/sorbet/rbi/todo.snapshot.rbi @@ -1,8 +1,10 @@ # typed: true +#⌄ enclosing_range_start currentgem 77 TODO# module TODO # ^^^^ definition currentgem 77 TODO# TODO_CONSTANT = 1 # ^^^^^^^^^^^^^ definition currentgem 77 TODO#TODO_CONSTANT. # ^^^^^^^^^^^^^^^^^ reference currentgem 77 TODO#TODO_CONSTANT. end +# ⌃ enclosing_range_end currentgem 77 TODO# diff --git a/test/scip/testdata/multifile/typed-false-mix/def_untyped.snapshot.rb b/test/scip/testdata/multifile/typed-false-mix/def_untyped.snapshot.rb index 774540908..e8561a256 100644 --- a/test/scip/testdata/multifile/typed-false-mix/def_untyped.snapshot.rb +++ b/test/scip/testdata/multifile/typed-false-mix/def_untyped.snapshot.rb @@ -1,5 +1,7 @@ # typed: false +#⌄ enclosing_range_start [..] C# class C # ^ definition [..] C# end +# ⌃ enclosing_range_end [..] C# diff --git a/test/scip/testdata/multifile/typed-false-mix/use_untyped.snapshot.rb b/test/scip/testdata/multifile/typed-false-mix/use_untyped.snapshot.rb index 8f20caae1..bd91a5a1d 100644 --- a/test/scip/testdata/multifile/typed-false-mix/use_untyped.snapshot.rb +++ b/test/scip/testdata/multifile/typed-false-mix/use_untyped.snapshot.rb @@ -3,10 +3,14 @@ require 'def_untyped' #^^^^^^^ reference [..] Kernel#require(). +#⌄ enclosing_range_start [..] N# module N # ^ definition [..] N# +# ⌄ enclosing_range_start [..] N#D# class D < C # ^ definition [..] N#D# # ^ reference [..] C# end +# ⌃ enclosing_range_end [..] N#D# end +# ⌃ enclosing_range_end [..] N# diff --git a/test/scip/testdata/nested_constants.snapshot.rb b/test/scip/testdata/nested_constants.snapshot.rb index 5bac23e6a..2ba91204b 100644 --- a/test/scip/testdata/nested_constants.snapshot.rb +++ b/test/scip/testdata/nested_constants.snapshot.rb @@ -3,30 +3,45 @@ # 3+-level constant qualifier walks in class names, ancestors, and references. # Exercises the recursion in saveQualifierReferences. +#⌄ enclosing_range_start [..] Outer# module Outer # ^^^^^ definition [..] Outer# +# ⌄ enclosing_range_start [..] Outer#Inner# module Inner # ^^^^^ definition [..] Outer#Inner# +# ⌄ enclosing_range_start [..] Outer#Inner#Deep# module Deep # ^^^^ definition [..] Outer#Inner#Deep# +# ⌄ enclosing_range_start [..] Outer#Inner#Deep#Base# class Base # ^^^^ definition [..] Outer#Inner#Deep#Base# +# ⌄ enclosing_range_start [..] Outer#Inner#Deep#Base#m(). def m; end # ^ definition [..] Outer#Inner#Deep#Base#m(). +# ⌃ enclosing_range_end [..] Outer#Inner#Deep#Base#m(). end +# ⌃ enclosing_range_end [..] Outer#Inner#Deep#Base# +# ⌄ enclosing_range_start [..] Outer#Inner#Deep#Mixin# module Mixin # ^^^^^ definition [..] Outer#Inner#Deep#Mixin# +# ⌄ enclosing_range_start [..] Outer#Inner#Deep#Mixin#helper(). def helper # ^^^^^^ definition [..] Outer#Inner#Deep#Mixin#helper(). "h" end +# ⌃ enclosing_range_end [..] Outer#Inner#Deep#Mixin#helper(). end +# ⌃ enclosing_range_end [..] Outer#Inner#Deep#Mixin# end +# ⌃ enclosing_range_end [..] Outer#Inner#Deep# end +# ⌃ enclosing_range_end [..] Outer#Inner# end +# ⌃ enclosing_range_end [..] Outer# # 4-level qualifier in class header and in superclass position. +#⌄ enclosing_range_start [..] Outer#Inner#Deep#Derived# class Outer::Inner::Deep::Derived < Outer::Inner::Deep::Base # ^^^^^ reference [..] Outer# # ^^^^^ reference [..] Outer#Inner# @@ -37,8 +52,10 @@ class Outer::Inner::Deep::Derived < Outer::Inner::Deep::Base # ^^^^ reference [..] Outer#Inner#Deep# # ^^^^ reference [..] Outer#Inner#Deep#Base# end +# ⌃ enclosing_range_end [..] Outer#Inner#Deep#Derived# # Qualified include in an ancestor expression. +#⌄ enclosing_range_start [..] WithDeepMixin# class WithDeepMixin # ^^^^^^^^^^^^^ definition [..] WithDeepMixin# include Outer::Inner::Deep::Mixin @@ -51,7 +68,9 @@ class WithDeepMixin # ^^^^^ reference [..] Outer#Inner#Deep#Mixin# # ^^^^^ reference [..] Outer#Inner#Deep#Mixin# end +# ⌃ enclosing_range_end [..] WithDeepMixin# +#⌄ enclosing_range_start [..] Object#use_nested(). def use_nested # ^^^^^^^^^^ definition [..] Object#use_nested(). _ = Outer::Inner::Deep::Base.new @@ -68,3 +87,4 @@ def use_nested # ^^^^^^ reference [..] Outer#Inner#Deep#Mixin#helper(). return end +# ⌃ enclosing_range_end [..] Object#use_nested(). diff --git a/test/scip/testdata/non_existent.snapshot.rb b/test/scip/testdata/non_existent.snapshot.rb index 4afe92e57..0111b592d 100644 --- a/test/scip/testdata/non_existent.snapshot.rb +++ b/test/scip/testdata/non_existent.snapshot.rb @@ -1,10 +1,14 @@ # typed: true +#⌄ enclosing_range_start [..] D# class D # ^ definition [..] D# end +# ⌃ enclosing_range_end [..] D# +#⌄ enclosing_range_start [..] C# class C < ::D # ^ definition [..] C# # ^ reference [..] D# end +# ⌃ enclosing_range_end [..] C# diff --git a/test/scip/testdata/opus.snapshot.rb b/test/scip/testdata/opus.snapshot.rb index 701607717..bbe3ff122 100644 --- a/test/scip/testdata/opus.snapshot.rb +++ b/test/scip/testdata/opus.snapshot.rb @@ -1,16 +1,20 @@ # typed: true +#⌄ enclosing_range_start [..] Opus#Base# class Opus::Base # ^^^^ reference [..] Opus# # ^^^^ definition [..] Opus#Base# end +# ⌃ enclosing_range_end [..] Opus#Base# +#⌄ enclosing_range_start [..] Opus#Derived# class Opus::Derived < Opus::Base # ^^^^ reference [..] Opus# # ^^^^^^^ definition [..] Opus#Derived# # ^^^^ reference [..] Opus# # ^^^^ reference [..] Opus#Base# end +# ⌃ enclosing_range_end [..] Opus#Derived# TYPES = T.let({ derived: -> { Opus::Derived } }, T::Hash[Symbol, T.proc.returns(T.class_of(Opus::Base))]) #^^^^^ definition [..] TYPES. @@ -30,6 +34,7 @@ class Opus::Derived < Opus::Base # ^^^^^^^ definition local 4$119448696 # ^^^^^^^^ reference [..] TYPES. +#⌄ enclosing_range_start [..] ABC# module ABC # ^^^ definition [..] ABC# TYPES_IN_MODULE = T.let({ derived: -> { Opus::Derived } }, T::Hash[Symbol, T.proc.returns(T.class_of(Opus::Base))]) @@ -44,7 +49,9 @@ module ABC # ^^^^^^^ definition local 4$119448696 # ^^^^^^^^ reference [..] ABC#TYPES_IN_MODULE. end +# ⌃ enclosing_range_end [..] ABC# +#⌄ enclosing_range_start [..] Other# class Other # ^^^^^ definition [..] Other# TYPES_IN_CLASS = T.let({ derived: -> { Opus::Derived } }, T::Hash[Symbol, T.proc.returns(T.class_of(Opus::Base))]) @@ -59,3 +66,4 @@ class Other # ^^^^^^^ definition local 4$119448696 # ^^^^^^^^ reference [..] Other#TYPES_IN_CLASS. end +# ⌃ enclosing_range_end [..] Other# diff --git a/test/scip/testdata/prepend_extend.snapshot.rb b/test/scip/testdata/prepend_extend.snapshot.rb index 32f967d8a..673ba042e 100644 --- a/test/scip/testdata/prepend_extend.snapshot.rb +++ b/test/scip/testdata/prepend_extend.snapshot.rb @@ -5,44 +5,61 @@ # field-inheritance / mixin-transitive code paths get a chance to surface # `is_reference` relationships for prepend/extend. +#⌄ enclosing_range_start [..] Greeter# module Greeter # ^^^^^^^ definition [..] Greeter# +# ⌄ enclosing_range_start [..] Greeter#hello(). def hello # ^^^^^ definition [..] Greeter#hello(). "hi" end +# ⌃ enclosing_range_end [..] Greeter#hello(). +# ⌄ enclosing_range_start [..] Greeter#set_via_greeter(). def set_via_greeter # ^^^^^^^^^^^^^^^ definition [..] Greeter#set_via_greeter(). @field = "g" # ^^^^^^ definition [..] Greeter#`@field`. # ^^^^^^^^^^^^ reference [..] Greeter#`@field`. end +# ⌃ enclosing_range_end [..] Greeter#set_via_greeter(). end +# ⌃ enclosing_range_end [..] Greeter# +#⌄ enclosing_range_start [..] PrependedMod# module PrependedMod # ^^^^^^^^^^^^ definition [..] PrependedMod# +# ⌄ enclosing_range_start [..] PrependedMod#hello(). def hello # ^^^^^ definition [..] PrependedMod#hello(). "prepended " + super end +# ⌃ enclosing_range_end [..] PrependedMod#hello(). +# ⌄ enclosing_range_start [..] PrependedMod#set_via_prepend(). def set_via_prepend # ^^^^^^^^^^^^^^^ definition [..] PrependedMod#set_via_prepend(). @field = "p" # ^^^^^^ definition [..] PrependedMod#`@field`. # ^^^^^^^^^^^^ reference [..] PrependedMod#`@field`. end +# ⌃ enclosing_range_end [..] PrependedMod#set_via_prepend(). end +# ⌃ enclosing_range_end [..] PrependedMod# +#⌄ enclosing_range_start [..] ClassyMethods# module ClassyMethods # ^^^^^^^^^^^^^ definition [..] ClassyMethods# +# ⌄ enclosing_range_start [..] ClassyMethods#klass_hi(). def klass_hi # ^^^^^^^^ definition [..] ClassyMethods#klass_hi(). "class hi" end +# ⌃ enclosing_range_end [..] ClassyMethods#klass_hi(). end +# ⌃ enclosing_range_end [..] ClassyMethods# +#⌄ enclosing_range_start [..] CombinedMix# class CombinedMix # ^^^^^^^^^^^ definition [..] CombinedMix# include Greeter @@ -56,13 +73,17 @@ class CombinedMix # ^^^^^^ reference [..] Kernel#extend(). # ^^^^^^^^^^^^^ reference [..] ClassyMethods# +# ⌄ enclosing_range_start [..] CombinedMix#read_field(). def read_field # ^^^^^^^^^^ definition [..] CombinedMix#read_field(). @field # ^^^^^^ reference [..] CombinedMix#`@field`. end +# ⌃ enclosing_range_end [..] CombinedMix#read_field(). end +# ⌃ enclosing_range_end [..] CombinedMix# +#⌄ enclosing_range_start [..] Object#use_combined(). def use_combined # ^^^^^^^^^^^^ definition [..] Object#use_combined(). c = CombinedMix.new @@ -88,3 +109,4 @@ def use_combined # ^^^^^^^^ reference [..] ClassyMethods#klass_hi(). return end +# ⌃ enclosing_range_end [..] Object#use_combined(). diff --git a/test/scip/testdata/prop.snapshot.rb b/test/scip/testdata/prop.snapshot.rb index 1b7e7c432..54d6b3e7c 100644 --- a/test/scip/testdata/prop.snapshot.rb +++ b/test/scip/testdata/prop.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] SomeODM# class SomeODM # ^^^^^^^ definition [..] SomeODM# extend T::Sig @@ -9,13 +10,18 @@ class SomeODM # ^ reference [..] T# # ^^^^^ reference [..] T#Props# +# ⌄ enclosing_range_start [..] SomeODM#`foo=`(). +# ⌄ enclosing_range_start [..] SomeODM#foo(). prop :foo, String # ^^^ definition [..] SomeODM#`foo=`(). # ^^^ definition [..] SomeODM#foo(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] SomeODM#`foo=`(). +# ⌃ enclosing_range_end [..] SomeODM#foo(). sig {returns(T.nilable(String))} # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] SomeODM#foo2(). def foo2; T.cast(T.unsafe(nil), T.nilable(String)); end # ^^^^ definition [..] SomeODM#foo2(). # ^ reference [..] T# @@ -24,60 +30,99 @@ def foo2; T.cast(T.unsafe(nil), T.nilable(String)); end # ^^^^^^^^^^^^^^^^^ definition local 1$1867563647 # ^^^^^^^ reference [..] ``#nilable(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] SomeODM#foo2(). sig {params(arg0: String).returns(String)} # ^^^^^^ reference [..] String# # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] SomeODM#`foo2=`(). def foo2=(arg0); T.cast(nil, String); end # ^^^^^ definition [..] SomeODM#`foo2=`(). # ^^^^^^ definition local 1$2116144614 # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] SomeODM#`foo2=`(). end +# ⌃ enclosing_range_end [..] SomeODM# +#⌄ enclosing_range_start [..] ForeignClass# class ForeignClass # ^^^^^^^^^^^^ definition [..] ForeignClass# end +# ⌃ enclosing_range_end [..] ForeignClass# +#⌄ enclosing_range_start [..] AdvancedODM# class AdvancedODM # ^^^^^^^^^^^ definition [..] AdvancedODM# include T::Props # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T# # ^^^^^ reference [..] T#Props# +# ⌄ enclosing_range_start [..] AdvancedODM#`default=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#default(). prop :default, String, default: "" # ^^^^^^^ definition [..] AdvancedODM#`default=`(). # ^^^^^^^ definition [..] AdvancedODM#default(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`default=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#default(). +# ⌄ enclosing_range_start [..] AdvancedODM#`t_nilable=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#t_nilable(). prop :t_nilable, T.nilable(String) # ^^^^^^^^^ definition [..] AdvancedODM#`t_nilable=`(). # ^^^^^^^^^ definition [..] AdvancedODM#t_nilable(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`t_nilable=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#t_nilable(). +# ⌄ enclosing_range_start [..] AdvancedODM#`array=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#array(). prop :array, Array # ^^^^^ definition [..] AdvancedODM#`array=`(). # ^^^^^ definition [..] AdvancedODM#array(). # ^^^^^ reference [..] Array# +# ⌃ enclosing_range_end [..] AdvancedODM#`array=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#array(). +# ⌄ enclosing_range_start [..] AdvancedODM#`t_array=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#t_array(). prop :t_array, T::Array[String] # ^^^^^^^ definition [..] AdvancedODM#`t_array=`(). # ^^^^^^^ definition [..] AdvancedODM#t_array(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`t_array=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#t_array(). +# ⌄ enclosing_range_start [..] AdvancedODM#`hash_of=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#hash_of(). prop :hash_of, T::Hash[Symbol, String] # ^^^^^^^ definition [..] AdvancedODM#`hash_of=`(). # ^^^^^^^ definition [..] AdvancedODM#hash_of(). # ^^^^^^ reference [..] Symbol# # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`hash_of=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#hash_of(). +# ⌄ enclosing_range_start [..] AdvancedODM#const_explicit(). prop :const_explicit, String, immutable: true # ^^^^^^^^^^^^^^ definition [..] AdvancedODM#const_explicit(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#const_explicit(). +# ⌄ enclosing_range_start [..] AdvancedODM#const(). const :const, String # ^^^^^ definition [..] AdvancedODM#const(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#const(). +# ⌄ enclosing_range_start [..] AdvancedODM#`enum_prop=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#enum_prop(). prop :enum_prop, String, enum: ["hello", "goodbye"] # ^^^^^^^^^ definition [..] AdvancedODM#`enum_prop=`(). # ^^^^^^^^^ definition [..] AdvancedODM#enum_prop(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`enum_prop=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#enum_prop(). +# ⌄ enclosing_range_start [..] AdvancedODM#`foreign_lazy=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#`foreign_lazy_!`(). +# ⌄ enclosing_range_start [..] AdvancedODM#foreign_lazy(). +# ⌄ enclosing_range_start [..] AdvancedODM#foreign_lazy_(). prop :foreign_lazy, String, foreign: -> {ForeignClass} # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] T#Boolean. # ^^^^^^^^^^^^ definition [..] AdvancedODM#`foreign_lazy=`(). @@ -88,6 +133,14 @@ class AdvancedODM # ^^ reference [..] Kernel# # ^^ reference [..] Kernel#lambda(). # ^^^^^^^^^^^^ reference [..] ForeignClass# +# ⌃ enclosing_range_end [..] AdvancedODM#`foreign_lazy=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#`foreign_lazy_!`(). +# ⌃ enclosing_range_end [..] AdvancedODM#foreign_lazy(). +# ⌃ enclosing_range_end [..] AdvancedODM#foreign_lazy_(). +# ⌄ enclosing_range_start [..] AdvancedODM#`foreign_proc=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#`foreign_proc_!`(). +# ⌄ enclosing_range_start [..] AdvancedODM#foreign_proc(). +# ⌄ enclosing_range_start [..] AdvancedODM#foreign_proc_(). prop :foreign_proc, String, foreign: proc {ForeignClass} # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] T#Boolean. # ^^^^^^^^^^^^ definition [..] AdvancedODM#`foreign_proc=`(). @@ -97,6 +150,14 @@ class AdvancedODM # ^^^^^^ reference [..] String# # ^^^^ reference [..] Kernel#proc(). # ^^^^^^^^^^^^ reference [..] ForeignClass# +# ⌃ enclosing_range_end [..] AdvancedODM#`foreign_proc=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#`foreign_proc_!`(). +# ⌃ enclosing_range_end [..] AdvancedODM#foreign_proc(). +# ⌃ enclosing_range_end [..] AdvancedODM#foreign_proc_(). +# ⌄ enclosing_range_start [..] AdvancedODM#`foreign_invalid=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#`foreign_invalid_!`(). +# ⌄ enclosing_range_start [..] AdvancedODM#foreign_invalid(). +# ⌄ enclosing_range_start [..] AdvancedODM#foreign_invalid_(). prop :foreign_invalid, String, foreign: proc { :not_a_type } # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] T#Boolean. # ^^^^^^^^^^^^^^^ definition [..] AdvancedODM#`foreign_invalid=`(). @@ -105,69 +166,117 @@ class AdvancedODM # ^^^^^^^^^^^^^^^ definition [..] AdvancedODM#foreign_invalid_(). # ^^^^^^ reference [..] String# # ^^^^ reference [..] Kernel#proc(). +# ⌃ enclosing_range_end [..] AdvancedODM#`foreign_invalid=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#`foreign_invalid_!`(). +# ⌃ enclosing_range_end [..] AdvancedODM#foreign_invalid(). +# ⌃ enclosing_range_end [..] AdvancedODM#foreign_invalid_(). +# ⌄ enclosing_range_start [..] AdvancedODM#`ifunset=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#ifunset(). prop :ifunset, String, ifunset: '' # ^^^^^^^ definition [..] AdvancedODM#`ifunset=`(). # ^^^^^^^ definition [..] AdvancedODM#ifunset(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`ifunset=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#ifunset(). +# ⌄ enclosing_range_start [..] AdvancedODM#`ifunset_nilable=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#ifunset_nilable(). prop :ifunset_nilable, T.nilable(String), ifunset: '' # ^^^^^^^^^^^^^^^ definition [..] AdvancedODM#`ifunset_nilable=`(). # ^^^^^^^^^^^^^^^ definition [..] AdvancedODM#ifunset_nilable(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`ifunset_nilable=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#ifunset_nilable(). +# ⌄ enclosing_range_start [..] AdvancedODM#`empty_hash_rules=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#empty_hash_rules(). prop :empty_hash_rules, String, {} # ^^^^^^^^^^^^^^^^ definition [..] AdvancedODM#`empty_hash_rules=`(). # ^^^^^^^^^^^^^^^^ definition [..] AdvancedODM#empty_hash_rules(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`empty_hash_rules=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#empty_hash_rules(). +# ⌄ enclosing_range_start [..] AdvancedODM#`hash_rules=`(). +# ⌄ enclosing_range_start [..] AdvancedODM#hash_rules(). prop :hash_rules, String, { enum: ["hello", "goodbye" ] } # ^^^^^^^^^^ definition [..] AdvancedODM#`hash_rules=`(). # ^^^^^^^^^^ definition [..] AdvancedODM#hash_rules(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] AdvancedODM#`hash_rules=`(). +# ⌃ enclosing_range_end [..] AdvancedODM#hash_rules(). end +# ⌃ enclosing_range_end [..] AdvancedODM# +#⌄ enclosing_range_start [..] PropHelpers# class PropHelpers # ^^^^^^^^^^^ definition [..] PropHelpers# include T::Props # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T# # ^^^^^ reference [..] T#Props# +# ⌄ enclosing_range_start [..] ``#token_prop(). def self.token_prop(opts={}); end # ^^^^^^^^^^ definition [..] ``#token_prop(). +# ⌃ enclosing_range_end [..] ``#token_prop(). +# ⌄ enclosing_range_start [..] ``#created_prop(). def self.created_prop(opts={}); end # ^^^^^^^^^^^^ definition [..] ``#created_prop(). +# ⌃ enclosing_range_end [..] ``#created_prop(). +# ⌄ enclosing_range_start [..] PropHelpers#`token=`(). +# ⌄ enclosing_range_start [..] PropHelpers#token(). token_prop # ^^^^^ definition [..] PropHelpers#`token=`(). # ^^^^^ definition [..] PropHelpers#token(). # ^^^^^^^^^^ reference [..] ``#token_prop(). # ^^^^^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] PropHelpers#`token=`(). +# ⌃ enclosing_range_end [..] PropHelpers#token(). +# ⌄ enclosing_range_start [..] PropHelpers#`created=`(). +# ⌄ enclosing_range_start [..] PropHelpers#created(). created_prop # ^^^^^^^ definition [..] PropHelpers#`created=`(). # ^^^^^^^ definition [..] PropHelpers#created(). # ^^^^^^^^^^^^ reference [..] ``#created_prop(). # ^^^^^^^^^^^^ reference [..] Float# +# ⌃ enclosing_range_end [..] PropHelpers#`created=`(). +# ⌃ enclosing_range_end [..] PropHelpers#created(). end +# ⌃ enclosing_range_end [..] PropHelpers# +#⌄ enclosing_range_start [..] PropHelpers2# class PropHelpers2 # ^^^^^^^^^^^^ definition [..] PropHelpers2# include T::Props # ^^^^^^^ reference [..] Module#include(). # ^ reference [..] T# # ^^^^^ reference [..] T#Props# +# ⌄ enclosing_range_start [..] ``#timestamped_token_prop(). def self.timestamped_token_prop(opts={}); end # ^^^^^^^^^^^^^^^^^^^^^^ definition [..] ``#timestamped_token_prop(). +# ⌃ enclosing_range_end [..] ``#timestamped_token_prop(). +# ⌄ enclosing_range_start [..] ``#created_prop(). def self.created_prop(opts={}); end # ^^^^^^^^^^^^ definition [..] ``#created_prop(). +# ⌃ enclosing_range_end [..] ``#created_prop(). +# ⌄ enclosing_range_start [..] PropHelpers2#`token=`(). +# ⌄ enclosing_range_start [..] PropHelpers2#token(). timestamped_token_prop # ^^^^^^^^^^^^^^^^^^^^^^ reference [..] ``#timestamped_token_prop(). # ^^^^^^^^^^^^^^^^^^^^^^ reference [..] String# # ^^^^^ definition [..] PropHelpers2#`token=`(). # ^^^^^ definition [..] PropHelpers2#token(). +# ⌃ enclosing_range_end [..] PropHelpers2#`token=`(). +# ⌃ enclosing_range_end [..] PropHelpers2#token(). +# ⌄ enclosing_range_start [..] PropHelpers2#created(). created_prop(immutable: true) # ^^^^^^^^^^^^ reference [..] ``#created_prop(). # ^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] PropHelpers2#created(). # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reference [..] Float# +# ⌃ enclosing_range_end [..] PropHelpers2#created(). end +# ⌃ enclosing_range_end [..] PropHelpers2# +#⌄ enclosing_range_start [..] Object#main(). def main # ^^^^ definition [..] Object#main(). SomeODM.new.foo @@ -310,3 +419,4 @@ def main # ^^^ reference [..] Class#new(). # ^^^^^^^^^^^^^^^^^ reference [..] AdvancedODM#`ifunset_nilable=`(). end +# ⌃ enclosing_range_end [..] Object#main(). diff --git a/test/scip/testdata/requires.snapshot.rb b/test/scip/testdata/requires.snapshot.rb index 563500542..757c73c71 100644 --- a/test/scip/testdata/requires.snapshot.rb +++ b/test/scip/testdata/requires.snapshot.rb @@ -10,9 +10,11 @@ require_relative 'non_existent_helper' #^^^^^^^^^^^^^^^^ reference [..] Kernel#require_relative(). +#⌄ enclosing_range_start [..] Object#lazy_load(). def lazy_load # ^^^^^^^^^ definition [..] Object#lazy_load(). require 'csv' # ^^^^^^^ reference [..] Kernel#require(). return end +# ⌃ enclosing_range_end [..] Object#lazy_load(). diff --git a/test/scip/testdata/requires_ancestor.snapshot.rb b/test/scip/testdata/requires_ancestor.snapshot.rb index cda83deb9..04d780c24 100644 --- a/test/scip/testdata/requires_ancestor.snapshot.rb +++ b/test/scip/testdata/requires_ancestor.snapshot.rb @@ -2,6 +2,7 @@ # Exercises T::Helpers `requires_ancestor { ... }`. +#⌄ enclosing_range_start [..] Greetable# module Greetable # ^^^^^^^^^ definition [..] Greetable# extend T::Helpers @@ -15,17 +16,23 @@ module Greetable sig { abstract.returns(String) } # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] Greetable#name(). def name; end # ^^^^ definition [..] Greetable#name(). +# ⌃ enclosing_range_end [..] Greetable#name(). sig { void } +# ⌄ enclosing_range_start [..] Greetable#greet(). def greet # ^^^^^ definition [..] Greetable#greet(). puts("Hello, " + name) # ^^^^ reference [..] Greetable#name(). end +# ⌃ enclosing_range_end [..] Greetable#greet(). end +# ⌃ enclosing_range_end [..] Greetable# +#⌄ enclosing_range_start [..] GreetableClass# class GreetableClass # ^^^^^^^^^^^^^^ definition [..] GreetableClass# extend T::Sig @@ -37,8 +44,11 @@ class GreetableClass sig { override.returns(String) } # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] GreetableClass#name(). def name # ^^^^ definition [..] GreetableClass#name(). "World" end +# ⌃ enclosing_range_end [..] GreetableClass#name(). end +# ⌃ enclosing_range_end [..] GreetableClass# diff --git a/test/scip/testdata/rescue.snapshot.rb b/test/scip/testdata/rescue.snapshot.rb index 31ee8b619..1cd6d5b45 100644 --- a/test/scip/testdata/rescue.snapshot.rb +++ b/test/scip/testdata/rescue.snapshot.rb @@ -1,10 +1,13 @@ # typed: true +#⌄ enclosing_range_start [..] MyError# class MyError < StandardError # ^^^^^^^ definition [..] MyError# # ^^^^^^^^^^^^^ reference [..] StandardError# end +# ⌃ enclosing_range_end [..] MyError# +#⌄ enclosing_range_start [..] Object#handle(). def handle(e) # ^^^^^^ definition [..] Object#handle(). # ^ definition local 1$780127187 @@ -14,7 +17,9 @@ def handle(e) # ^^^^^^^ reference [..] Kernel#inspect(). # ^^^^ reference [..] Kernel#to_s(). end +# ⌃ enclosing_range_end [..] Object#handle(). +#⌄ enclosing_range_start [..] Object#f(). def f # ^ definition [..] Object#f(). begin @@ -34,3 +39,4 @@ def f # ^^ reference local 4$3809224601 end end +# ⌃ enclosing_range_end [..] Object#f(). diff --git a/test/scip/testdata/singleton.snapshot.rb b/test/scip/testdata/singleton.snapshot.rb index 818fec3a9..cc3917751 100644 --- a/test/scip/testdata/singleton.snapshot.rb +++ b/test/scip/testdata/singleton.snapshot.rb @@ -1,5 +1,6 @@ # typed: true +#⌄ enclosing_range_start [..] A# class A # ^ definition [..] A# include Singleton @@ -7,12 +8,16 @@ class A # ^^^^^^^^^ reference [..] Singleton# # ^^^^^^^^^ reference [..] Singleton# end +# ⌃ enclosing_range_end [..] A# # Singleton supports inheritance, turning the sub-class into a singleton as well. +#⌄ enclosing_range_start [..] B# class B < A; end # ^ definition [..] B# # ^ reference [..] A# +# ⌃ enclosing_range_end [..] B# +#⌄ enclosing_range_start [..] C# class C # ^ definition [..] C# include Singleton @@ -23,7 +28,9 @@ class C # ^^^^^^ reference [..] Kernel#extend(). final! end +# ⌃ enclosing_range_end [..] C# +#⌄ enclosing_range_start [..] Object#f(). def f # ^ definition [..] Object#f(). return [A.instance, B.instance, C.instance] @@ -34,3 +41,4 @@ def f # ^ reference [..] C# # ^^^^^^^^ reference [..] Singleton#SingletonClassMethods#instance(). end +# ⌃ enclosing_range_end [..] Object#f(). diff --git a/test/scip/testdata/singleton_class.snapshot.rb b/test/scip/testdata/singleton_class.snapshot.rb index f084e5a43..2f4ccf59b 100644 --- a/test/scip/testdata/singleton_class.snapshot.rb +++ b/test/scip/testdata/singleton_class.snapshot.rb @@ -5,29 +5,42 @@ # in field_inheritance.rb. This fixture captures the current behavior so a # future fix has a regression target. +#⌄ enclosing_range_start [..] K# class K # ^ definition [..] K# +# ⌄ enclosing_range_start [..] ``# class << self # ^^^^ definition [..] ``# +# ⌄ enclosing_range_start [..] ``#class_method(). def class_method # ^^^^^^^^^^^^ definition [..] ``#class_method(). @counter = 0 # ^^^^^^^^ definition [..] ``#`@counter`. # ^^^^^^^^^^^^ reference [..] ``#`@counter`. end +# ⌃ enclosing_range_end [..] ``#class_method(). +# ⌄ enclosing_range_start [..] ``#read_counter(). def read_counter # ^^^^^^^^^^^^ definition [..] ``#read_counter(). @counter # ^^^^^^^^ reference [..] ``#`@counter`. end +# ⌃ enclosing_range_end [..] ``#read_counter(). +# ⌄ enclosing_range_start [..] ``#`name=`(). +# ⌄ enclosing_range_start [..] ``#name(). attr_accessor :name # ^^^^ definition [..] ``#`name=`(). # ^^^^ definition [..] ``#name(). +# ⌃ enclosing_range_end [..] ``#`name=`(). +# ⌃ enclosing_range_end [..] ``#name(). end +# ⌃ enclosing_range_end [..] ``# end +# ⌃ enclosing_range_end [..] K# +#⌄ enclosing_range_start [..] Object#use_K(). def use_K # ^^^^^ definition [..] Object#use_K(). K.class_method @@ -46,3 +59,4 @@ def use_K # ^^^^ reference [..] ``#name(). return end +# ⌃ enclosing_range_end [..] Object#use_K(). diff --git a/test/scip/testdata/struct.snapshot.rb b/test/scip/testdata/struct.snapshot.rb index cea90ceb5..441e2021b 100644 --- a/test/scip/testdata/struct.snapshot.rb +++ b/test/scip/testdata/struct.snapshot.rb @@ -1,23 +1,36 @@ # typed: true # From Sorbet docs https://sorbet.org/docs/tstruct +#⌄ enclosing_range_start [..] S# +#⌄ enclosing_range_start [..] S#initialize(). class S < T::Struct # ^ definition [..] S# # ^ definition [..] S#initialize(). # ^ reference [..] T# # ^^^^^^ reference [..] T#Struct# +# ⌄ enclosing_range_start [..] S#`prop_i=`(). +# ⌄ enclosing_range_start [..] S#prop_i(). prop :prop_i, Integer # ^^^^^^ definition [..] S#`prop_i=`(). # ^^^^^^ definition [..] S#prop_i(). # ^^^^^^^ reference [..] Integer# +# ⌃ enclosing_range_end [..] S#`prop_i=`(). +# ⌃ enclosing_range_end [..] S#prop_i(). +# ⌄ enclosing_range_start [..] S#const_s(). const :const_s, T.nilable(String) # ^^^^^^^ definition [..] S#const_s(). # ^^^^^^ reference [..] String# +# ⌃ enclosing_range_end [..] S#const_s(). +# ⌄ enclosing_range_start [..] S#const_f(). const :const_f, Float, default: 0.5 # ^^^^^^^ definition [..] S#const_f(). # ^^^^^ reference [..] Float# +# ⌃ enclosing_range_end [..] S#const_f(). end +# ⌃ enclosing_range_end [..] S# +# ⌃ enclosing_range_end [..] S#initialize(). +#⌄ enclosing_range_start [..] Object#f(). def f # ^ definition [..] Object#f(). s = S.new(prop_i: 3) @@ -45,7 +58,14 @@ def f # ^^^^^^^^ reference [..] S#`prop_i=`(). return end +# ⌃ enclosing_range_end [..] Object#f(). +#⌄ enclosing_range_start [..] POINT# +#⌄ enclosing_range_start [..] POINT# +# ⌄ enclosing_range_start [..] POINT#`x=`(). +# ⌄ enclosing_range_start [..] POINT#x(). +# ⌄ enclosing_range_start [..] POINT#`y=`(). +# ⌄ enclosing_range_start [..] POINT#y(). POINT = Struct.new(:x, :y) do #^^^^^ reference [..] POINT# #^^^^^ definition [..] POINT# @@ -56,14 +76,23 @@ def f # ^ definition [..] POINT#`y=`(). # ^ definition [..] POINT#y(). # ^ reference [..] BasicObject# +# ⌃ enclosing_range_end [..] POINT#`x=`(). +# ⌃ enclosing_range_end [..] POINT#x(). +# ⌃ enclosing_range_end [..] POINT#`y=`(). +# ⌃ enclosing_range_end [..] POINT#y(). +# ⌄ enclosing_range_start [..] POINT#array(). def array # ^^^^^ definition [..] POINT#array(). [x, y] # ^ reference [..] POINT#x(). # ^ reference [..] POINT#y(). end +# ⌃ enclosing_range_end [..] POINT#array(). end +# ⌃ enclosing_range_end [..] POINT# +# ⌃ enclosing_range_end [..] POINT# +#⌄ enclosing_range_start [..] Object#g(). def g # ^ definition [..] Object#g(). p = POINT.new(0, 1) @@ -80,3 +109,4 @@ def g # ^ reference [..] POINT#x(). return end +# ⌃ enclosing_range_end [..] Object#g(). diff --git a/test/scip/testdata/super_call.snapshot.rb b/test/scip/testdata/super_call.snapshot.rb index 748baee44..9893f862c 100644 --- a/test/scip/testdata/super_call.snapshot.rb +++ b/test/scip/testdata/super_call.snapshot.rb @@ -3,30 +3,40 @@ # Explicit-arg super (as opposed to implicit-arg, which is implicit_super_arg.rb) # Documents whether scip-ruby emits a reference to the parent method at `super`. +#⌄ enclosing_range_start [..] Parent# class Parent # ^^^^^^ definition [..] Parent# +# ⌄ enclosing_range_start [..] Parent#greet(). def greet(name) # ^^^^^ definition [..] Parent#greet(). # ^^^^ definition local 1$4213039946 "Hi, " + name # ^^^^ reference local 1$4213039946 end +# ⌃ enclosing_range_end [..] Parent#greet(). end +# ⌃ enclosing_range_end [..] Parent# +#⌄ enclosing_range_start [..] Child# class Child < Parent # ^^^^^ definition [..] Child# # ^^^^^^ reference [..] Parent# +# ⌄ enclosing_range_start [..] Child#greet(). def greet(name) # ^^^^^ definition [..] Child#greet(). # ^^^^ definition local 1$4213039946 super(name) # ^^^^ reference local 1$4213039946 end +# ⌃ enclosing_range_end [..] Child#greet(). end +# ⌃ enclosing_range_end [..] Child# +#⌄ enclosing_range_start [..] GrandChild# class GrandChild < Child # ^^^^^^^^^^ definition [..] GrandChild# # ^^^^^ reference [..] Child# +# ⌄ enclosing_range_start [..] GrandChild#greet(). def greet(name) # ^^^^^ definition [..] GrandChild#greet(). # ^^^^ definition local 1$4213039946 @@ -36,8 +46,11 @@ def greet(name) base + "!" # ^^^^ reference local 2$4213039946 end +# ⌃ enclosing_range_end [..] GrandChild#greet(). end +# ⌃ enclosing_range_end [..] GrandChild# +#⌄ enclosing_range_start [..] Object#trigger(). def trigger # ^^^^^^^ definition [..] Object#trigger(). _ = GrandChild.new.greet("x") @@ -47,3 +60,4 @@ def trigger # ^^^^^ reference [..] GrandChild#greet(). return end +# ⌃ enclosing_range_end [..] Object#trigger(). diff --git a/test/scip/testdata/t_helpers.snapshot.rb b/test/scip/testdata/t_helpers.snapshot.rb index 249f49cde..98a83b3bd 100644 --- a/test/scip/testdata/t_helpers.snapshot.rb +++ b/test/scip/testdata/t_helpers.snapshot.rb @@ -3,6 +3,7 @@ # T.must, T.assert_type!, T.absurd, T.bind. Other T.* operations # (T.let, T.cast, T.unsafe, T.reveal_type) are already covered elsewhere. +#⌄ enclosing_range_start [..] Container# class Container # ^^^^^^^^^ definition [..] Container# extend T::Sig @@ -11,6 +12,7 @@ class Container sig { params(x: T.nilable(String)).returns(Integer) } # ^^^^^^ reference [..] String# # ^^^^^^^ reference [..] Integer# +# ⌄ enclosing_range_start [..] Container#use_must(). def use_must(x) # ^^^^^^^^ definition [..] Container#use_must(). # ^ definition local 1$2138952860 @@ -20,9 +22,11 @@ def use_must(x) # ^ reference local 1$2138952860 # ^^^^^^ reference [..] String#length(). end +# ⌃ enclosing_range_end [..] Container#use_must(). sig { params(x: T.untyped).returns(Integer) } # ^^^^^^^ reference [..] Integer# +# ⌄ enclosing_range_start [..] Container#use_assert_type(). def use_assert_type(x) # ^^^^^^^^^^^^^^^ definition [..] Container#use_assert_type(). # ^ definition local 1$3012239264 @@ -33,6 +37,7 @@ def use_assert_type(x) x + 1 # ^ reference local 1$3012239264 end +# ⌃ enclosing_range_end [..] Container#use_assert_type(). Variant = T.type_alias { T.any(Integer, String) } # ^^^^^^^ definition [..] Container#Variant. @@ -42,6 +47,7 @@ def use_assert_type(x) sig { params(x: Variant).returns(Integer) } # ^^^^^^^ reference [..] Container#Variant. # ^^^^^^^ reference [..] Integer# +# ⌄ enclosing_range_start [..] Container#use_absurd(). def use_absurd(x) # ^^^^^^^^^^ definition [..] Container#use_absurd(). # ^ definition local 1$4004738816 @@ -59,8 +65,10 @@ def use_absurd(x) T.absurd(x) end end +# ⌃ enclosing_range_end [..] Container#use_absurd(). sig { returns(T.proc.void) } +# ⌄ enclosing_range_start [..] Container#use_bind(). def use_bind # ^^^^^^^^ definition [..] Container#use_bind(). proc do @@ -74,4 +82,6 @@ def use_bind nil end end +# ⌃ enclosing_range_end [..] Container#use_bind(). end +# ⌃ enclosing_range_end [..] Container# diff --git a/test/scip/testdata/test_case.snapshot.rb b/test/scip/testdata/test_case.snapshot.rb index 8c5637d1c..f3f5a8a3c 100644 --- a/test/scip/testdata/test_case.snapshot.rb +++ b/test/scip/testdata/test_case.snapshot.rb @@ -1,10 +1,13 @@ # typed: strict +#⌄ enclosing_range_start [..] ActiveSupport#TestCase# class ActiveSupport::TestCase # ^^^^^^^^^^^^^ reference [..] ActiveSupport# # ^^^^^^^^ definition [..] ActiveSupport#TestCase# end +# ⌃ enclosing_range_end [..] ActiveSupport#TestCase# +#⌄ enclosing_range_start [..] MyTest# class MyTest < ActiveSupport::TestCase # ^^^^^^ definition [..] MyTest# # ^^^^^^^^^^^^^ reference [..] ActiveSupport# @@ -14,18 +17,23 @@ class MyTest < ActiveSupport::TestCase # Helper instance method sig { params(test: T.untyped).returns(T::Boolean) } # ^^^^^^^ reference [..] T#Boolean. +# ⌄ enclosing_range_start [..] MyTest#assert(). def assert(test) # ^^^^^^ definition [..] MyTest#assert(). # ^^^^ definition local 1$2774883451 test ? true : false end +# ⌃ enclosing_range_end [..] MyTest#assert(). # Helper method to direct calls to `test` instead of Kernel#test sig { params(args: T.untyped, block: T.nilable(T.proc.void)).void } +# ⌄ enclosing_range_start [..] ``#test(). def self.test(*args, &block) # ^^^^ definition [..] ``#test(). end +# ⌃ enclosing_range_end [..] ``#test(). +# ⌄ enclosing_range_start [..] MyTest#``(). setup do # ^^^^^ definition [..] MyTest#``(). @a = T.let(1, Integer) @@ -34,17 +42,24 @@ def self.test(*args, &block) # ^^^^^^^ definition local 1$2938098190 # ^^^^^^^ reference [..] Integer# end +# ⌃ enclosing_range_end [..] MyTest#``(). +# ⌄ enclosing_range_start [..] MyTest#test_valid_method_call(). test "valid method call" do # ^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#test_valid_method_call(). end +# ⌃ enclosing_range_end [..] MyTest#test_valid_method_call(). +# ⌄ enclosing_range_start [..] MyTest#test_block_is_evaluated_in_the_context_of_an_instance(). test "block is evaluated in the context of an instance" do # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] MyTest#test_block_is_evaluated_in_the_context_of_an_instance(). assert true end +# ⌃ enclosing_range_end [..] MyTest#test_block_is_evaluated_in_the_context_of_an_instance(). end +# ⌃ enclosing_range_end [..] MyTest# +#⌄ enclosing_range_start [..] NoMatchTest# class NoMatchTest < ActiveSupport::TestCase # ^^^^^^^^^^^ definition [..] NoMatchTest# # ^^^^^^^^^^^^^ reference [..] ActiveSupport# @@ -53,31 +68,44 @@ class NoMatchTest < ActiveSupport::TestCase # ^^^^^^ reference [..] Kernel#extend(). sig { params(block: T.proc.void).void } +# ⌄ enclosing_range_start [..] ``#setup(). def self.setup(&block); end # ^^^^^ definition [..] ``#setup(). +# ⌃ enclosing_range_end [..] ``#setup(). sig { params(block: T.proc.void).void } +# ⌄ enclosing_range_start [..] ``#teardown(). def self.teardown(&block); end # ^^^^^^^^ definition [..] ``#teardown(). +# ⌃ enclosing_range_end [..] ``#teardown(). end +# ⌃ enclosing_range_end [..] NoMatchTest# +#⌄ enclosing_range_start [..] NoParentClass# class NoParentClass # ^^^^^^^^^^^^^ definition [..] NoParentClass# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). sig { params(block: T.proc.void).void } +# ⌄ enclosing_range_start [..] ``#setup(). def self.setup(&block); end # ^^^^^ definition [..] ``#setup(). +# ⌃ enclosing_range_end [..] ``#setup(). sig { params(block: T.proc.void).void } +# ⌄ enclosing_range_start [..] ``#teardown(). def self.teardown(&block); end # ^^^^^^^^ definition [..] ``#teardown(). +# ⌃ enclosing_range_end [..] ``#teardown(). sig { params(a: T.untyped, b: T.untyped).void } +# ⌄ enclosing_range_start [..] NoParentClass#assert_equal(). def assert_equal(a, b); end # ^^^^^^^^^^^^ definition [..] NoParentClass#assert_equal(). +# ⌃ enclosing_range_end [..] NoParentClass#assert_equal(). +# ⌄ enclosing_range_start [..] NoParentClass#``(). setup do # ^^^^^ definition [..] NoParentClass#``(). @a = T.let(1, Integer) @@ -86,16 +114,22 @@ def assert_equal(a, b); end # ^^^^^^^ definition local 1$2938098190 # ^^^^^^^ reference [..] Integer# end +# ⌃ enclosing_range_end [..] NoParentClass#``(). +# ⌄ enclosing_range_start [..] NoParentClass#test_it_works(). test "it works" do # ^^^^^^^^^^ definition [..] NoParentClass#test_it_works(). assert_equal 1, @a end +# ⌃ enclosing_range_end [..] NoParentClass#test_it_works(). +# ⌄ enclosing_range_start [..] NoParentClass#teardown(). teardown do # ^^^^^^^^ definition [..] NoParentClass#teardown(). @a = 5 # ^^ definition [..] NoParentClass#`@a`. # ^^^^^^ reference [..] NoParentClass#`@a`. end +# ⌃ enclosing_range_end [..] NoParentClass#teardown(). end +# ⌃ enclosing_range_end [..] NoParentClass# diff --git a/test/scip/testdata/type_change.snapshot.rb b/test/scip/testdata/type_change.snapshot.rb index 5e5067bc0..930800bf0 100644 --- a/test/scip/testdata/type_change.snapshot.rb +++ b/test/scip/testdata/type_change.snapshot.rb @@ -1,6 +1,7 @@ # typed: true # options: showDocs +#⌄ enclosing_range_start [..] Object#assign_different_branches(). def assign_different_branches(b) # ^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] Object#assign_different_branches(). # documentation @@ -30,7 +31,9 @@ def assign_different_branches(b) end return end +# ⌃ enclosing_range_end [..] Object#assign_different_branches(). +#⌄ enclosing_range_start [..] Object#change_different_branches(). def change_different_branches(b) # ^^^^^^^^^^^^^^^^^^^^^^^^^ definition [..] Object#change_different_branches(). # documentation @@ -66,7 +69,9 @@ def change_different_branches(b) end return end +# ⌃ enclosing_range_end [..] Object#change_different_branches(). +#⌄ enclosing_range_start [..] Object#loop_type_change(). def loop_type_change(bs) # ^^^^^^^^^^^^^^^^ definition [..] Object#loop_type_change(). # documentation @@ -123,7 +128,9 @@ def loop_type_change(bs) end return end +# ⌃ enclosing_range_end [..] Object#loop_type_change(). +#⌄ enclosing_range_start [..] C# class C # ^ definition [..] C# # documentation @@ -137,6 +144,7 @@ class C # | @k (T.untyped) # | ``` +# ⌄ enclosing_range_start [..] C#change_type(). def change_type(b) # ^^^^^^^^^^^ definition [..] C#change_type(). # documentation @@ -205,8 +213,11 @@ def change_type(b) # | ``` end end +# ⌃ enclosing_range_end [..] C#change_type(). end +# ⌃ enclosing_range_end [..] C# +#⌄ enclosing_range_start [..] D# class D < C # ^ definition [..] D# # documentation @@ -214,6 +225,7 @@ class D < C # | class D < C # | ``` # ^ reference [..] C# +# ⌄ enclosing_range_start [..] D#change_type(). def change_type(b) # ^^^^^^^^^^^ definition [..] D#change_type(). # documentation @@ -278,4 +290,6 @@ def change_type(b) # relation definition=[..] C#`@k`. end end +# ⌃ enclosing_range_end [..] D#change_type(). end +# ⌃ enclosing_range_end [..] D# diff --git a/test/scip/testdata/type_docs.snapshot.rb b/test/scip/testdata/type_docs.snapshot.rb index c67392425..0b34b84bc 100644 --- a/test/scip/testdata/type_docs.snapshot.rb +++ b/test/scip/testdata/type_docs.snapshot.rb @@ -1,6 +1,7 @@ # typed: true # options: showDocs +#⌄ enclosing_range_start [..] M# module M # ^ definition [..] M# # documentation @@ -13,6 +14,7 @@ module M # ^^^^^^^ reference [..] Integer# # ^^^^^^ reference [..] String# # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] M#js_add(). def js_add(x, y) # ^^^^^^ definition [..] M#js_add(). # documentation @@ -54,4 +56,6 @@ def js_add(x, y) # | return ret (T.noreturn) # | ``` end +# ⌃ enclosing_range_end [..] M#js_add(). end +# ⌃ enclosing_range_end [..] M# diff --git a/test/scip/testdata/typed_false.snapshot.rb b/test/scip/testdata/typed_false.snapshot.rb index f7884ca89..951e2697c 100644 --- a/test/scip/testdata/typed_false.snapshot.rb +++ b/test/scip/testdata/typed_false.snapshot.rb @@ -1,14 +1,18 @@ # typed: false +#⌄ enclosing_range_start [..] C# class C # ^ definition [..] C# +# ⌄ enclosing_range_start [..] C#f(). def f # ^ definition [..] C#f(). @f = 0 # ^^ definition [..] C#`@f`. # ^^^^^^ reference [..] C#`@f`. end +# ⌃ enclosing_range_end [..] C#f(). +# ⌄ enclosing_range_start [..] C#g(). def g(x) # ^ definition [..] C#g(). # ^ definition local 1$3792446982 @@ -17,4 +21,6 @@ def g(x) # ^^ reference [..] C#`@f`. # ^ reference [..] C#f(). end +# ⌃ enclosing_range_end [..] C#g(). end +# ⌃ enclosing_range_end [..] C# diff --git a/test/scip/testdata/typed_ignore.snapshot.rb b/test/scip/testdata/typed_ignore.snapshot.rb index e989b21c3..288bf8920 100644 --- a/test/scip/testdata/typed_ignore.snapshot.rb +++ b/test/scip/testdata/typed_ignore.snapshot.rb @@ -3,15 +3,19 @@ # `typed: ignore` files are parsed but not typechecked. This locks in what # (if anything) the indexer emits for such files. +#⌄ enclosing_range_start [..] IgnoredKlass# class IgnoredKlass # ^^^^^^^^^^^^ definition [..] IgnoredKlass# +# ⌄ enclosing_range_start [..] IgnoredKlass#m(). def m # ^ definition [..] IgnoredKlass#m(). @field = 1 # ^^^^^^ definition [..] IgnoredKlass#`@field`. # ^^^^^^^^^^ reference [..] IgnoredKlass#`@field`. end +# ⌃ enclosing_range_end [..] IgnoredKlass#m(). end +# ⌃ enclosing_range_end [..] IgnoredKlass# IgnoredKlass.new.m #^^^^^^^^^^^^ reference [..] IgnoredKlass# diff --git a/test/scip/testdata/typed_strong.snapshot.rb b/test/scip/testdata/typed_strong.snapshot.rb index 7dabf47d7..0e2c7b417 100644 --- a/test/scip/testdata/typed_strong.snapshot.rb +++ b/test/scip/testdata/typed_strong.snapshot.rb @@ -3,6 +3,7 @@ # At `typed: strong` Sorbet requires that nothing be T.untyped. Locks in # indexer behavior for fully-typed code. +#⌄ enclosing_range_start [..] StrongClass# class StrongClass # ^^^^^^^^^^^ definition [..] StrongClass# extend T::Sig @@ -11,6 +12,7 @@ class StrongClass sig { params(x: Integer).returns(Integer) } # ^^^^^^^ reference [..] Integer# # ^^^^^^^ reference [..] Integer# +# ⌄ enclosing_range_start [..] StrongClass#add_one(). def add_one(x) # ^^^^^^^ definition [..] StrongClass#add_one(). # ^ definition local 1$272034907 @@ -18,10 +20,12 @@ def add_one(x) # ^ reference local 1$272034907 # ^ reference [..] Integer#+(). end +# ⌃ enclosing_range_end [..] StrongClass#add_one(). sig { params(x: String).returns(String) } # ^^^^^^ reference [..] String# # ^^^^^^ reference [..] String# +# ⌄ enclosing_range_start [..] StrongClass#shout(). def shout(x) # ^^^^^ definition [..] StrongClass#shout(). # ^ definition local 1$3089998242 @@ -29,14 +33,18 @@ def shout(x) # ^ reference local 1$3089998242 # ^^^^^^ reference [..] String#upcase(). end +# ⌃ enclosing_range_end [..] StrongClass#shout(). end +# ⌃ enclosing_range_end [..] StrongClass# +#⌄ enclosing_range_start [..] StrongUse# class StrongUse # ^^^^^^^^^ definition [..] StrongUse# extend T::Sig # ^^^^^^ reference [..] Kernel#extend(). sig { void } +# ⌄ enclosing_range_start [..] StrongUse#call_them(). def call_them # ^^^^^^^^^ definition [..] StrongUse#call_them(). s = StrongClass.new @@ -53,4 +61,6 @@ def call_them # ^^^^^ reference [..] StrongClass#shout(). nil end +# ⌃ enclosing_range_end [..] StrongUse#call_them(). end +# ⌃ enclosing_range_end [..] StrongUse# diff --git a/test/scip/testdata/yield_block.snapshot.rb b/test/scip/testdata/yield_block.snapshot.rb index 51c486f82..bff788dfb 100644 --- a/test/scip/testdata/yield_block.snapshot.rb +++ b/test/scip/testdata/yield_block.snapshot.rb @@ -4,6 +4,7 @@ # in SCIPIndexer.cc treats YieldLoadArg / LoadYieldParams / YieldParamPresent # as no-ops. +#⌄ enclosing_range_start [..] Object#with_yield(). def with_yield(x) # ^^^^^^^^^^ definition [..] Object#with_yield(). # ^ definition local 1$1452685967 @@ -12,13 +13,17 @@ def with_yield(x) yield x + 1 # ^ reference local 1$1452685967 end +# ⌃ enclosing_range_end [..] Object#with_yield(). +#⌄ enclosing_range_start [..] Object#with_yield_no_args(). def with_yield_no_args # ^^^^^^^^^^^^^^^^^^ definition [..] Object#with_yield_no_args(). yield yield end +# ⌃ enclosing_range_end [..] Object#with_yield_no_args(). +#⌄ enclosing_range_start [..] Object#use_blocks(). def use_blocks # ^^^^^^^^^^ definition [..] Object#use_blocks(). total = 0 @@ -40,3 +45,4 @@ def use_blocks total # ^^^^^ reference local 1$1737801135 end +# ⌃ enclosing_range_end [..] Object#use_blocks(). diff --git a/test/scip_test_runner.cc b/test/scip_test_runner.cc index 5e07681a9..5069adf06 100644 --- a/test/scip_test_runner.cc +++ b/test/scip_test_runner.cc @@ -330,6 +330,11 @@ struct FormatOptions { bool showDocs; }; +struct EnclosingMarker { + SCIPRange range; + string symbol; +}; + void formatSnapshot(const scip::Document &document, FormatOptions options, std::ostream &out) { UnorderedMap symbolTable{}; symbolTable.reserve(document.symbols_size()); @@ -351,6 +356,29 @@ void formatSnapshot(const scip::Document &document, FormatOptions options, std:: {"ruby latest", "[..]"}, // core and stdlib {"_global_ latest", "[global]"}}); }; + UnorderedMap> enclosingByStartLine{}; + UnorderedMap> enclosingByEndLine{}; + for (auto &occ : occurrences) { + if (occ.enclosing_range_size() == 0) { + continue; + } + EnclosingMarker marker{SCIPRange(occ.enclosing_range()), occ.symbol()}; + enclosingByStartLine[marker.range.start.line].push_back(marker); + enclosingByEndLine[marker.range.end.line].push_back(marker); + } + for (auto &entry : enclosingByStartLine) { + fast_sort(entry.second, [](const EnclosingMarker &a, const EnclosingMarker &b) -> bool { + return a.range.start.column != b.range.start.column ? a.range.start.column < b.range.start.column + : a.symbol < b.symbol; + }); + } + for (auto &entry : enclosingByEndLine) { + fast_sort(entry.second, [](const EnclosingMarker &a, const EnclosingMarker &b) -> bool { + return a.range.end.column != b.range.end.column ? a.range.end.column < b.range.end.column + : a.symbol < b.symbol; + }); + } + size_t occ_i = 0; std::ifstream input(document.relative_path()); ENFORCE(input.is_open(), "failed to open document to read source code"); @@ -360,6 +388,12 @@ void formatSnapshot(const scip::Document &document, FormatOptions options, std:: if (!line.empty() && line.back() == '\r') { line.pop_back(); } + if (auto it = enclosingByStartLine.find(lineNumber); it != enclosingByStartLine.end()) { + for (auto &marker : it->second) { + out << '#' << string(marker.range.start.column - 1, ' ') << "⌄ enclosing_range_start " + << formatSymbol(marker.symbol) << '\n'; + } + } out << ' '; // For '#' out << absl::StrReplaceAll(line, {{"\t", " "}}); out << '\n'; @@ -440,6 +474,12 @@ void formatSnapshot(const scip::Document &document, FormatOptions options, std:: out << '\n'; } } + if (auto it = enclosingByEndLine.find(lineNumber); it != enclosingByEndLine.end()) { + for (auto &marker : it->second) { + out << '#' << string(marker.range.end.column >= 2 ? marker.range.end.column - 2 : 0, ' ') + << "⌃ enclosing_range_end " << formatSymbol(marker.symbol) << '\n'; + } + } } }