class Crystal::MatchContext

• Crystal::MatchContext
• Reference
• Object

Overview

Context information about a method lookup match.

For example, given:

class Foo
  class Baz
  end

  def method
    Baz.new
  end
end

class Bar < Foo
  class Baz
  end
end

Bar.new.method # => #<Foo::Baz:0x10c1a2fc0>

we have that:

• #defining_type is Foo, because it's the type that define the method
• #instantiated_type is Bar, because the method was invoked, and thus instantiated there

#defining_type is needed because when we search types in method, we must search them starting from Foo, not from Bar. #instantiated_type is needed because method resolution will start from Bar.

TODO this might slightly change in the future, we should probably instantiate the method on Foo+ to avoid having duplicated methods, at least for reference types, even though that might lead to broader method resolutions (because a method call in method will now be searched in Foo+, not in Bar)

Defined in:

Constructors

• .new(instantiated_type : Crystal::Type, defining_type : Crystal::Type, bound_free_vars : Nil | Hash(String, Crystal::ASTNode | Crystal::Type) = nil, def_free_vars : Nil | Array(String) = nil, self_restriction_type : Crystal::Type | Nil = nil)

Instance Method Summary

• #bind_free_var(name, type)
• #bound_free_var?(name)
• #bound_free_vars : Hash(String, TypeVar) | Nil

  Any instance variables associated with the method instantiation

• #clone
• #def_free_vars : Array(String) | Nil

  Def free variables (`def ...

• #def_free_vars=(def_free_vars : Array(String) | Nil)

  Def free variables (`def ...

• #defining_type : Type

  The type that defines the method

• #defining_type=(defining_type : Type)

  The type that defines the method

• #has_unbound_free_var?(name)
• #instantiated_type : Type

  The type where the method was instantiated

• #instantiated_type=(instantiated_type : Type)

  The type where the method was instantiated

• #self_restriction_type : Type | Nil

  The type that represents self (overriding #instantiated_type), used to resolve restrictions properly when a macro def is about to be copied to a subtype

• #self_restriction_type=(self_restriction_type : Type | Nil)

  The type that represents self (overriding #instantiated_type), used to resolve restrictions properly when a macro def is about to be copied to a subtype

• #self_type : Type

  Returns the type that corresponds to using self when looking a type relative to this context.

Constructor Detail

Instance Method Detail

class Foo
  def foo(&block : self ->)
    ...
  end
end

class Bar < Foo
end

Bar.new.foo { |x| }