steep-relaxed 1.9.3.3

data/manual/annotations.md

@@ -0,0 +1,181 @@
+# Annotations
+
+## Core Annotations
+
+### Variable type
+
+Variable type annotation tells type of local variable.
+
+#### Example
+
+```
+# @type var x: String
+# @type var klass: Class
+```
+
+#### Syntax
+
+* `@type` `var` *x* `:` *type*
+
+### Self type
+
+Self type annotation tells type of `self`.
+
+#### Example
+
+```
+# @type self: Object
+```
+
+#### Syntax
+
+* `@type` `self` `:` *type*
+
+### Instance variable type
+
+Instance variable type annotation tells type of instance variable.
+This annotation applies to instance variable of current context.
+If it's written in `module` declaration, it applies to instance variable of the module, not its instance.
+
+#### Example
+
+```
+# @type ivar @owner: Person
+```
+
+#### Syntax
+
+* `@type` `ivar` *ivar* `:` *type*
+
+### Global variable type
+
+Global variable type annotation tells type of global variable.
+
+#### Example
+
+```
+# @type gvar $LOAD_PATH: Array<String>
+```
+
+#### Syntax
+
+* `@type` `gvar` *gvar* `:` *type*
+
+### Constant type
+
+Constant type annotation tells type of constant.
+Note that constant resolution is done syntactically.
+Annotation on `File::Append` does not apply to `::File::Append`.
+
+#### Example
+
+```
+# @type const File::Append : Integer
+```
+
+#### Syntax
+
+* `@type` `const` *const* `:` *type*
+
+### Method type annotation
+
+Method type annotation tells type of method being implemented in current scope.
+
+This annotation is used to tell types of method parameters and its body.
+Union method type cannot be written.
+
+#### Example
+
+```
+# @type method foo: (String) -> any
+```
+
+#### Syntax
+
+* `@type` `method` *method* `:` *single method type*
+
+## Module Annotations
+
+Module annotations is about defining modules and classes in Ruby.
+This kind of annotations should be written in module context.
+
+### Instance type annotation
+
+Instance type annotation tells type of instance of class or module which is being defined.
+
+#### Example
+
+```
+# @type instance: Foo
+```
+
+#### Syntax
+
+* `@type` `instance` `:` *type*
+
+### Module type annotation
+
+Module type annotation tells type of module of class or module which is being defined.
+
+#### Example
+
+```
+# @type module: Foo.class
+```
+
+#### Syntax
+
+* `@type` `module` `:` *type*
+
+### Instance/module ivar type annotation
+
+This annotation tells instance variable of instance.
+
+#### Example
+
+```
+# @type instance ivar @x: String
+# @type module ivar @klass: String.class
+```
+
+#### Syntax
+
+* `@type` `instance` `ivar` *ivar* `:` *type*
+* `@type` `module` `ivar` *ivar* `:` *type*
+
+## Type assertion
+
+Type assertion allows declaring type of an expression inline, without introducing new local variable with variable type annotation.
+
+### Example
+
+```
+array = [] #: Array[String]
+
+path = nil #: Pathname?
+```
+
+##### Syntax
+
+* `#:` *type*
+
+## Type application
+
+Type application is for generic method calls.
+
+### Example
+
+```
+table = accounts.each_with_object({}) do |account, table| #$ Hash[String, Account]
+  table[account.email] = account
+end
+```
+
+The `each_with_object` method has `[T] (T) { (Account, T) -> void } -> T`,
+and the type application syntax directly specifies the type of `T`.
+
+So the resulting type is `(Hash[String, Account]) { (Account, Hash[String, Account]) -> void } -> Hash[String, Account]`.
+
+#### Syntax
+
+* `#$` *type*

data/manual/ignore.md

@@ -0,0 +1,20 @@
+# Ignore diagnostics
+
+Steep allows you to ignore diagnostics by adding comments to your code.
+
+```ruby
+# Ignoring a range of lines
+
+# steep:ignore:start
+
+foo()      # NoMethod is detected, but ignored
+
+# steep:ignore:end
+```
+
+```ruby
+# Ignoring a specific line
+
+foo() # steep:ignore
+foo() # steep:ignore NoMethod
+```