feat(rivet/resolver+rivetc.resolver): allow use of static functions without using Self.

Author: StunxFS

lib/rivet/src/resolver/exprs.ri

@@ -270,14 +270,6 @@ extend Resolver {
         } else if self.self_sym_is_set {
             if sym := self.self_sym.scope.find(ident.name) {
                 if !(sym is ast.TypeSym(type_sym) && type_sym.info is .Placeholder) {
-                    if sym is ast.Func {
-                        mut err := report.error_builder(
-                            "cannot find `{}` in this scope".fmt(ident.name), ident.pos
-                        );
-                        err.add_help("use `Self.{}()` instead", sym.name);
-                        err.emit();
-                        return;
-                    }
                     ident.found = true;
                     ident.is_sym = true;
                     ident.sym = sym;

lib/std/src/fs/Path.c.ri

@@ -56,7 +56,7 @@ pub struct Path {
     /// Returns `true` if `path` is a file.
     #[inline]
     pub func is_file(path: string) -> bool {
-        return Self.exists(path) && !Self.is_directory(path);
+        return exists(path) && !is_directory(path);
     }
 
     /// Returns `true` if `path` is absolute.
@@ -142,7 +142,7 @@ pub struct Path {
     /// Files that end with `.`, or that start with `.` and have no other `.` in their
     /// name, are considered to have no extension.
     pub func extension(path: string) -> string {
-        filename := Self.file_name(path);
+        filename := file_name(path);
         index := filename.last_index_of_byte('.') ?? return "";
         return if index == 0 || index + 1 >= filename.len {
             ""
@@ -164,7 +164,7 @@ pub struct Path {
         mut have_abs := false;
         mut max_size: uint := 0;
         for i, p in paths {
-            if Self.is_absolute(p) {
+            if is_absolute(p) {
                 first_index = i;
                 have_abs = true;
                 max_size = 0;
@@ -234,8 +234,8 @@ pub struct Path {
     /// resolve to the same path (after calling `resolve` on each), a zero-length
     /// string is returned.
     pub func relative(from_: string, to: string) -> !string {
-        _ = Self.resolve(from_)!;
-        _ = Self.resolve(to)!;
+        _ = resolve(from_)!;
+        _ = resolve(to)!;
         mut from_it := from_.tokenize(SEPARATOR);
         mut to_it := to.tokenize(SEPARATOR);
         while {
@@ -315,8 +315,8 @@ pub struct Path {
                 if this_path.is_empty() {
                     continue;
                 }
-                prev_sep := Self.is_separator(prev_path[prev_path.len - 1]);
-                this_sep := Self.is_separator(this_path[0]);
+                prev_sep := is_separator(prev_path[prev_path.len - 1]);
+                this_sep := is_separator(this_path[0]);
                 sum += (!prev_sep && !this_sep).to_uint();
                 sum += if prev_sep && this_sep { this_path.len - 1 } else { this_path.len };
                 prev_path = this_path;
@@ -339,8 +339,8 @@ pub struct Path {
             if this_path.is_empty() {
                 continue;
             }
-            prev_sep := Self.is_separator(prev_path[prev_path.len - 1]);
-            this_sep := Self.is_separator(this_path[0]);
+            prev_sep := is_separator(prev_path[prev_path.len - 1]);
+            this_sep := is_separator(this_path[0]);
             if !prev_sep && !this_sep {
                 unsafe {
                     buf[buf_index] = SEPARATOR;
@@ -369,13 +369,13 @@ pub struct Path {
         if path.is_empty() {
             return cwd;
         }
-        rpath := Self.resolve(path)!;
+        rpath := resolve(path)!;
         if rpath == "." {
             return cwd;
         }
-        if Self.is_absolute(rpath) {
+        if is_absolute(rpath) {
             return rpath;
         }
-        return Self.resolve(Self.join(cwd, rpath)!)!;
+        return resolve(join(cwd, rpath)!)!;
     }
 }

rivetc/src/resolver.py

@@ -413,21 +413,11 @@ def resolve_ident(self, ident):
             ident.is_sym = True
         elif self.self_sym:
             if s := self.self_sym.find(ident.name):
-                if isinstance(
+                if not (isinstance(
                     s, sym.Type
-                ) and s.kind == sym.TypeKind.Placeholder:
-                    report.error(
-                        f"cannot find `{ident.name}` in this scope", ident.pos
-                    )
-                    ident.not_found = True
-                elif isinstance(s, sym.Func):
-                    report.error(
-                        f"cannot find `{ident.name}` in this scope", ident.pos
-                    )
-                    report.help(f"use `Self.{s.name}()` instead")
-                    ident.not_found = True
-                ident.sym = s
-                ident.is_sym = True
+                ) and s.kind == sym.TypeKind.Placeholder):
+                    ident.sym = s
+                    ident.is_sym = True
         if ident.sym == None and ident.obj == None:
             report.error(f"cannot find `{ident.name}` in this scope", ident.pos)
             ident.not_found = True