Implement socket operations in Inko

Instead of relying on Rust code exposed through runtime library
functions, all socket operations are now implemented in Inko's standard
library. For TLS sockets we rely on callbacks for performing TLS reads
and writes, such that we don't need to expose any socket logic to the
TLS code.

By making these changes we're now fully in control of the socket logic,
the functionality we want to support, and how we want to support it. In
addition, we can drop the dependency on the socket2 crate.

In case of TLS sockets this may also result in a more efficient
implementation, as encountering EAGAIN/EWOULDBLOCK only retries the
low-level read/write instead of the entire TLS operation, though it's
difficult to say whether this makes a measurable difference.

This fixes #752.

Changelog: changed

compiler/src/hir.rs

@@ -2467,7 +2467,7 @@ impl<'a> LowerToHir<'a> {
             // We special-case this instruction because we need to attach extra
             // type information, but don't want to introduce a dedicated
             // `size_of` keyword just for this.
-            if node.name.name == "size_of_type_parameter" {
+            if node.name.name == "size_of_type_name" {
                 return self.size_of(node);
             }
 

compiler/src/llvm/passes.rs

@@ -1538,17 +1538,30 @@ impl<'shared, 'module, 'ctx> LowerMethod<'shared, 'module, 'ctx> {
                     }
                     Intrinsic::IntSwapBytes => {
                         let reg_var = self.variables[&ins.register];
-                        let val_var = self.variables[&ins.arguments[0]];
-                        let val = self.builder.load_int(val_var);
-                        let fun = self.module.intrinsic(
-                            "llvm.bswap",
-                            &[self.builder.context.i64_type().into()],
-                        );
-                        let res = self
+                        let val_reg = ins.arguments[0];
+                        let val_var = self.variables[&val_reg];
+
+                        // This is done such that we can use this intrinsic with
+                        // different integer types.
+                        let val_typ = self.variable_types[&val_reg];
+                        let signed = self
+                            .method
+                            .registers
+                            .value_type(val_reg)
+                            .is_signed_int(&self.shared.state.db);
+                        let val = self
+                            .builder
+                            .load(val_typ, val_var)
+                            .into_int_value();
+                        let fun =
+                            self.module.intrinsic("llvm.bswap", &[val_typ]);
+                        let swapped = self
                             .builder
                             .call(fun, &[val.into()])
                             .into_int_value();
 
+                        let res = self.builder.int_to_int(swapped, 64, signed);
+
                         self.builder.store(reg_var, res);
                     }
                     Intrinsic::IntAbsolute => {

compiler/src/mir/mod.rs

@@ -2158,6 +2158,11 @@ impl Mir {
                         Instruction::Send(i) => {
                             used[i.method.0 as usize] = true;
                         }
+                        // Extern methods with a body shouldn't be removed if we
+                        // create pointers to them.
+                        Instruction::MethodPointer(i) => {
+                            used[i.method.0 as usize] = true;
+                        }
                         Instruction::CallDynamic(i) => {
                             let id = i.method;
                             let tid = id

rt/Cargo.toml

@@ -43,16 +43,12 @@ rustls-pemfile = "^2.1"
 # https://github.com/inko-lang/inko/issues/329 for more details.
 once_cell = "1.9"
 
-[target.'cfg(all(unix, not(target_os = "macos"), not(target_os = "ios"), not(target_os = "tvos")))'.dependencies]
+[target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]
 rustls-native-certs = "0.7"
 webpki = { package = "rustls-webpki", version = "0.102", default-features = false }
 
-[target.'cfg(any(target_os = "macos", target_os = "ios", target_os = "tvos"))'.dependencies]
+[target.'cfg(any(target_os = "macos"))'.dependencies]
 core-foundation = "0.9"
 core-foundation-sys = "0.8"
 security-framework = { version = "2.10", features = ["OSX_10_14"] }
 security-framework-sys = { version = "2.10", features = ["OSX_10_14"] }
-
-[dependencies.socket2]
-version = "^0.5"
-features = ["all"]

rt/src/result.rs

@@ -1,9 +1,9 @@
 use rustix::io::Errno;
 use std::io;
 
-const OK: i64 = 0;
-const NONE: i64 = 1;
-const ERROR: i64 = 2;
+pub(crate) const OK: i64 = 0;
+pub(crate) const NONE: i64 = 1;
+pub(crate) const ERROR: i64 = 2;
 
 pub(crate) fn error_to_int(error: io::Error) -> i64 {
     let code = if let Some(code) = error.raw_os_error() {

rt/src/runtime.rs

@@ -3,7 +3,6 @@ mod class;
 mod env;
 mod float;
 mod general;
-mod helpers;
 mod int;
 mod process;
 mod random;