Allow the use of 'Self' for creating instances

This (re)adds support for using 'Self' to create instances of types when
used inside static or instance methods defined on a type. For example,
you can now do this:

    type User {
      let @name: String

      fn static new(name: String) -> User {
        Self(name: name)
      }
    }

This fixes #821.

Changelog: added

Author: yorickpeterse

compiler/src/type_check/expressions.rs

@@ -17,7 +17,7 @@ use types::{
     IdentifierKind, IntrinsicCall, MethodId, MethodLookup, ModuleId, Receiver,
     Sign, Symbol, ThrowKind, TraitId, TraitInstance, TypeArguments, TypeBounds,
     TypeEnum, TypeId, TypeInstance, TypeRef, Variable, VariableId, CALL_METHOD,
-    DEREF_POINTER_FIELD,
+    DEREF_POINTER_FIELD, SELF_TYPE,
 };
 
 const IGNORE_VARIABLE: &str = "_";
@@ -3788,6 +3788,20 @@ impl<'a> CheckMethodBody<'a> {
                     return TypeRef::Error;
                 }
                 MethodLookup::None => {
+                    if name == SELF_TYPE {
+                        match self.self_type {
+                            TypeEnum::TypeInstance(ins) => {
+                                let id = ins.instance_of();
+
+                                return self.new_type_instance(node, scope, id);
+                            }
+                            TypeEnum::Type(id) => {
+                                return self.new_type_instance(node, scope, id);
+                            }
+                            _ => {}
+                        }
+                    }
+
                     match self.module.use_symbol(self.db_mut(), name) {
                         Some(Symbol::Method(method)) => {
                             // The receiver of imported module methods is the

compiler/src/type_check/mod.rs

@@ -9,7 +9,7 @@ use types::format::format_type;
 use types::{
     Block, Closure, Database, MethodId, ModuleId, Symbol, TraitId,
     TraitInstance, TypeArguments, TypeBounds, TypeEnum, TypeId, TypeInstance,
-    TypeParameterId, TypeRef,
+    TypeParameterId, TypeRef, NEVER_TYPE, SELF_TYPE,
 };
 
 pub(crate) mod define_types;
@@ -333,35 +333,41 @@ impl<'a> DefineTypeSignature<'a> {
             // compared to physical types, so we handle them here rather than
             // handling them first.
             match name.as_str() {
-                "Never" if !self.rules.allow_never => {
+                NEVER_TYPE if !self.rules.allow_never => {
                     self.state.diagnostics.error(
                         DiagnosticId::InvalidType,
-                        "the 'Never' type can't be used in this context",
+                        format!(
+                            "the '{}' type can't be used in this context",
+                            NEVER_TYPE
+                        ),
                         self.file(),
                         node.location,
                     );
 
                     return TypeRef::Error;
                 }
-                "Never" => {
+                NEVER_TYPE => {
                     if kind == RefKind::Default {
                         TypeRef::Never
                     } else {
                         self.state.diagnostics.error(
                             DiagnosticId::InvalidType,
-                            "'Never' can't be borrowed",
+                            format!("'{}' can't be borrowed", NEVER_TYPE),
                             self.file(),
                             node.location,
                         );
 
                         return TypeRef::Error;
                     }
                 }
-                "Self" => {
+                SELF_TYPE => {
                     if !self.rules.allow_self {
                         self.state.diagnostics.error(
                             DiagnosticId::InvalidType,
-                            "the 'Self' type can't be used in this context",
+                            format!(
+                                "the '{}' type can't be used in this context",
+                                SELF_TYPE
+                            ),
                             self.file(),
                             node.location,
                         );

std/fixtures/diagnostics/new_instance_using_self_name.inko

@@ -0,0 +1,33 @@
+trait Trait {
+  fn required -> Self
+
+  fn default -> Self
+}
+
+type User {
+  let @name: String
+
+  fn static example1 -> Self {
+    Self(name: 'Alice')
+  }
+
+  fn example2 -> Self {
+    Self(name: 'Alice')
+  }
+}
+
+impl Trait for User {
+  fn required -> Self {
+    Self(name: 'Alice')
+  }
+
+  fn default -> Self {
+    Self(name: 'Alice')
+  }
+}
+
+fn example1 {
+  Self(name: 'Alice')
+}
+
+# new_instance_using_self_name.inko:30:3 error(invalid-symbol): the symbol 'Self' is undefined

types/src/format.rs

@@ -3,7 +3,7 @@ use crate::{
     Arguments, ClosureId, Database, ForeignType, Inline, MethodId, MethodKind,
     ModuleId, Ownership, Sign, TraitId, TraitInstance, TypeArguments, TypeEnum,
     TypeId, TypeInstance, TypeKind, TypeParameterId, TypePlaceholderId,
-    TypeRef, Visibility,
+    TypeRef, Visibility, NEVER_TYPE, SELF_TYPE,
 };
 
 const MAX_FORMATTING_DEPTH: usize = 8;
@@ -317,7 +317,7 @@ impl FormatType for TraitInstance {
         if self.self_type {
             match buffer.self_type {
                 Some(TypeEnum::TraitInstance(_)) | None => {
-                    buffer.write("Self");
+                    buffer.write(SELF_TYPE);
                     return;
                 }
                 Some(e) => return e.format_type(buffer),
@@ -487,7 +487,7 @@ impl FormatType for TypeRef {
 
                 id.format_type(buffer);
             }
-            TypeRef::Never => buffer.write("Never"),
+            TypeRef::Never => buffer.write(NEVER_TYPE),
             TypeRef::Error => buffer.write("<error>"),
             TypeRef::Unknown => buffer.write("<unknown>"),
             TypeRef::Placeholder(id) => id.format_type(buffer),

types/src/lib.rs

@@ -91,6 +91,8 @@ pub const RESULT_ERROR: &str = "Error";
 pub const ARRAY_WITH_CAPACITY: &str = "with_capacity";
 pub const ARRAY_PUSH: &str = "push";
 pub const ARRAY_INTERNAL_NAME: &str = "$Array";
+pub const SELF_TYPE: &str = "Self";
+pub const NEVER_TYPE: &str = "Never";
 
 /// The name of the pseudo field used to deference a pointer.
 pub const DEREF_POINTER_FIELD: &str = "0";