TODO: test this

@return
182409
@SuppressWarnings("unchecked")
  protected Class<T> getParameterizedType() {
    Class<T> clazz = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass())
        .getActualTypeArguments()[0];
    return clazz;
  }
312496
function clone() {
    var cloned = new this.constructor(this.client);
    cloned._method = this._method;
    cloned._single = assign({}, this._single);
    cloned._options = assign({}, this._options);
    cloned._statements = this._statements.slice();
    return cloned;
  }
937240
private function doTransition() : self
    {
        switch ($this->getState()) {
            case self::STATE_G:
                $this->doTransitionFromG();
                break;

            case self::STATE_F:
                $this->doTransitionFromF();
                break;

            case self::STATE_E:
                $this->doTransitionFromE();
                break;

            case self::STATE_D:
                $this->doTransitionFromD();
                break;

            case self::STATE_C:
                $this->doTransitionFromC();
                break;

            case self::STATE_B:
                $this->doTransitionFromB();
                break;

            case self::STATE_A:
                $this->doTransitionFromA();
                break;

            case self::STATE_Y:
                $this->doTransitionFromY();
                break;
        }

        return $this;
    }
1076504
function() {
          // TODO: remove unshifting 
          expected.unshift(actual)
          this.result = matcher.match.apply(this, expected)
          this.passed = negate ? !this.result : this.result
          if (!this.passed) this.message = matcher.message.call(this, actual, expected, negate, matcher.name)
          return this
        }
545035
public function boolean()
    {
        $message = ['%s is {{not|}} a boolean', $this->value];
        $this->assert(is_bool($this->value), $message);

        return $this;
    }
819515
public boolean getState()
    {
        boolean returnValue = true;
        if (m_objTarget instanceof String)
        {
            String fieldString = this.getString();
            returnValue = m_objTarget.equals(fieldString); // True if == target value
        }
        else
        {
            Object fieldString = this.getData();
            returnValue = m_objTarget.equals(fieldString); // True if == target value
        }
        if (m_bTrueIfMatch)
            return returnValue;
        else
            return !returnValue;
    }
807098
function() {
			if (this.parent) {
				var ix = this.parent.children.indexOf(this);
				if (~ix) {
					this.parent.children.splice(ix, 1);
				}
			}
			
			return this;
		}
817260
public function check()
    {
        try {
            try {
                $this->result(
                    $this->resource->checker->setTarget($this)->checkTarget(
                        $this
                    )
                );
            } catch (\Exception $exception) {
                report($exception);

                $this->exceptionResult($exception);
            }
        } catch (\Throwable $error) {
            report($error);

            $this->exceptionResult($error);
        }

        $this->moveChecksBackToTarget();

        return $this;
    }
1328043
public static <T> Predicate<T> notNull() {
        return new Predicate<T>() {
            @Override
            public boolean test(T testValue) {
                return testValue != null;
            }
        };
    }
1033542
public <T> Local<T> getThis(TypeId<T> type) {
        if (thisLocal == null) {
            throw new IllegalStateException("static methods cannot access 'this'");
        }
        return coerce(thisLocal, type);
    }
740793
public static boolean equal(Object thisObject, Object thatObject) {
        return thisObject == null ? thatObject == null : thisObject.equals(thatObject);
    }
553772
@Override
	public T get() {
		T result = object;
		if (result == null) {
			synchronized (this) {
				result = object;
				if (result == null) {
					object = result = init();
				}
			}
		}
		return result;
	}
124999
function() { 
            var l = this.coeffs.length;
            while(l--) {
                var c = this.coeffs[l];
                var equalsZero = c.equals(0);
                if(c && equalsZero) {
                    if(l === 0) break;
                    this.coeffs.pop();
                }
                else break;
            }

            return this;
        }
262753
function(){
            if(!this.current){
                return this.getCurrent();
            }

            var index = this.targets.indexOf(this.current);
            if(index === 0){
                index = this.targets.length - 1;
            } else {
                index--;
            }
            this.setCurrent(this.targets[index]);

            return this.current;
        }
1173216
public <TOut> Task<TOut> cast() {
    @SuppressWarnings("unchecked")
    Task<TOut> task = (Task<TOut>) this;
    return task;
  }
1284631
public Context createChild(){
        Context c = new Context();
        c.memoryHeap = memoryHeap;
        c.parent = this;
        this.children.add(c);
        return c;
    }
187538
public static function instance(): self
    {
        if (!self::$instance) {
            self::$instance = new self(
                InvocableInspector::instance(),
                FunctionSignatureInspector::instance(),
                FunctionHookGenerator::instance()
            );
        }

        return self::$instance;
    }