class Animal {
    let name: String
}

struct Animal { String name; }
Animal Animal_init(Animal self, String name) { ... }

Animal animal = malloc(sizeof(Animal));
Animal_init(animal, "foo");

class String { i8* bytes; size_t len; }
class CharacterView { String* string; }

opt test.ll -S -always-inline
; ModuleID = 'test.ll'
source_filename = "test.ll"

declare void @foo(i32)

; Function Attrs: alwaysinline
define i32 @"class.Int.=="(i32, i32) #0 {
entry:
  %2 = add i32 %0, %1
  ret i32 %2
}

define i32 @main(i32, i8**) {
entry:
  call void @foo(i32 2)
  ret i32 0
}

attributes #0 = { alwaysinline }

 int add(int b, int c)

func add(b: Int, c: Int)

import header "glibc.h"

 @opt(size) @request(inline)
  func add() {}

func add(a: Int, b: Int) -> Int llvm {
entry:
    ret add (i32 %0, %1)
}

public class Pointer<Type> llvm {
     layout { <Type> }
     define @<Name>.method.dereference() {
     }
}

public class whatever(foo) -> bar llvm {
     layout {  }
     define <stuff>
}

 func whatever(types) -> ReturnValue llvm { llvm code }

public class Pointer<T> {

    public func dereference() -> T llvm {
    define <returnType> <name>(<returnType>*) alwaysinline {
    entry:
        %1 = load <returnType>, <returnType>* %0
        ret %1
    }
    }

    public func getptr(at: Int64) -> Pointer<T> {
    define <returnType> <name>(i64) alwaysinline {
        %1 = getelementptr <returnType>, <returnType>, i64 %0
        ret %1
    }
    }

}

inline fn <returnType> <name>(at: Int64) --llvm {
    result = getelementptr <returnType>, <returnType>, i64 %0
    return result
}

/**
 * A primitive class representing a low-level pointer object. The pointer class
 * is an akward class in the sense it has a bunch of compiler glue to make it
 * functional.
 *
 * This definition only offers to specify the behavior of _functions_ of Pointer
 * instances. No fields exist because the generated code for `Pointer<id>` is
 * always `(id)*`.
 */
public class Pointer<T> {

    public func dereference() -> T llvm {
    define <returnType> <name>(<returnType>*) alwaysinline {
    entry: