public static func >=(lhs: Self, rhs: Self) llvm {
    define i1 <name>(<param>, <param>) alwaysinline {
    entry:
        %2 = call i1 "<methodRoot>.=="(<param> %0, <param> %1)
        br i1 %2, label %isTrue, %tryGt
    isTrue:
        ret i1 1
    isFalse:
        ret i1 0
    tryGt:
        %3 = call i1 "<methodRoot>.>"(<param> %0, <param> %1)
        br i1 %3, label %isTrue, %isFalse
    }
    }

vsl:parser> a.b(foo: bar)
token [ 'foo', 7 ]
readline.js:973
            throw err;
            ^

Error: foo,7
Unexpected ["foo",7]

                 arguments:
                  [ [ ArgumentCall {
                        parentScope: null,
                        parentNode: null,
                        queueQualifier: null,
                        arguments:
                         ExpressionStatement {
                           parentScope: null,
                           parentNode: null,
                           queueQualifier: null,
                           expression:
                            Identifier {
                              parentScope: null,

import Node from './node';

/**
 * Matches a subscript expression inside a PropertyExpression
 *
 * @example
 * head[tail]
 */

export default class Subscript extends Node {
    /**
     * Creates a subscript
     *
     * @param {Expression} expression the provided expression
     * @param {Object} position a position from nearley
     */
    constructor (expression: any, position: Object) {
        super(position);

        /** @type {Expression} */
        this.expression = expression;
    }

vsl:transform> var a: T = f(a: b)
{
    var a: T = (f).(b)
}

vsl:transform> var a: T = f(a: b)
{
    var a: T = (f).(a,7: b)
}

vsl:transform> f(a: b)
readline.js:973
            throw err;
            ^

TypeError: Cannot read property '0' of null

    at new ArgumentCall (/home/ubuntu/workspace/lib/vsl/parser/nodes/argumentCall.js:60:26)

vsl:transform> f(a: b)
{
    (f).(a: b)
}

vsl:transform> func f(a: T, b: U) internal(linkage)
{
    func f(a:T, b:U)(a: T, b: U) internal(linkage)
}

@primitive(/#startgoat.+?#endgoat/)
public class GoatLiteral {
    init(from primitive: Token) { ... }
}

interface Goat {
     public func f(a: T)
}

define void MySubclass.method.f(T* a) { ... }
struct Goat g = { &MySubclass.method.f }

var mycstring: CString = "halo"

var mycstring: CString = "halo".cPointer

import ConstaintType from '../constaintType';
import TypeConstraint from '../typeConstraint';
import TypeResolver from '../typeResolver';

/**
 * Resolves `ExpressionStatement`s
 */
export default class RootResolver extends TypeResolver {

    /**
     * @param {function(offer: ConstraintType): ?TypeConstaint} negotiator - The
     *     function which will handle or reject all negotiation requests. Use
     *     `{ nil }` to reject all offers (bad idea though).
     */
    constructor(
        node: Node,

SpecialArgument: 4,
SpecialLoop: 5,
SpecialIdentifier: 6,

$ ./vsl -r
vsl:transform> var a = b
readline.js:973
            throw err;
            ^

Error: Use of undeclared identifier b

func f(a: Int) -> Double
func f(a: Double) -> Int
var a = 1.0
var b = f(a)
var c: Double c

print "Source file name was: #{#sourcefile} on #{#date}"

Process proc = Runtime.getRuntime().exec(new String[] {
"/bin/sh",
"-c",
"echo $PPID"
});

if (proc.waitFor() == 0) {
InputStream in = proc.getInputStream();
int available = in.available();
byte[] outputBytes = new byte[available];

in.read(outputBytes);
String pid = new String(outputBytes);

System.out.println("Your pid is " + pid);
}

public func strcmp(s1: CString, s2: CString) -> Int internal(strcmp)

public typealias CString = Pointer<Char>

func f(a: Int) -> String { ... }
func f(a: Double) -> Int { ... }

let a: String = f(a: f(a: 5))

# Type Resolver
These are a series of classes and functions which serve to perform type
deduction on `ExpressionStatement`s. Because examples such as these exist:

```swift
var a: T = b
```

where `typeof b is T`, the `T` context is needed to perform the cast. These are
considered as "Context Constriants" which are generate as much as possible, then
one-by-one each is resolved. If ambiguity or no applicable type could be fount
then an error is thrown.

## Process
There are two main processes:

 - Constraints

func f(a: Double) -> Void { ... }

var a = 1
f(a: a)