FJTypeSystemDefinition.java

package it.xsemantics.example.fj.typesystem.fj;

import it.xsemantics.example.fj.typesystem.fj.rules.*;

import it.xtypes.runtime.RuleFailedException;
import it.xtypes.runtime.RuntimeRule;
import it.xtypes.runtime.RuntimeRules;
import it.xtypes.runtime.RuntimeTypeSystem;
import it.xtypes.runtime.TypeSystemResult;
import it.xtypes.runtime.TypeSystemResultPair;
import it.xtypes.runtime.TypingJudgmentEnvironment;

import it.xsemantics.example.fj.fj.FjPackage;

/**
 * Automatically generated by XTypeS, http://xtypes.sourceforge.net
 * Do not modify it.
 * This class should be instantiated with Google Guide injector.
 */
public class FJTypeSystemDefinition extends RuntimeTypeSystem {

	protected FjPackage basicPackage = FjPackage.eINSTANCE;

	public FJTypeSystemDefinition() {
		RuntimeRules rules = new RuntimeRules();
		rules.add(new SubClassTypeRule());
		rules.add(new SubTypeTypeRule());
		rules.add(new SubTypeClassTypeRule());
		rules.add(new SubTypeBasicTypeRule());
		rules.add(new SubTypeSequencesTypeRule());
		rules.add(new TIntConstantTypeRule());
		rules.add(new StringConstantTypeRule());
		rules.add(new BoolConstantTypeRule());
		rules.add(new TThisTypeRule());
		rules.add(new TParamTypeRule());
		rules.add(new TVariableTypeRule());
		rules.add(new TFieldTypeRule());
		rules.add(new TMethodBodyTypeRule());
		rules.add(new TNewTypeRule());
		rules.add(new TMessageTypeRule());
		rules.add(new TMethodCallTypeRule());
		rules.add(new TFieldSelectionTypeRule());
		rules.add(new TSelectionTypeRule());
		rules.add(new TCastTypeRule());
		rules.add(new TTypeEqualsTypeRule());
		rules.add(new TParamsEqualsTypeRule());
		rules.add(new TMethodOverrideTypeRule());
		rules.add(new TMethodOkTypeRule());
		rules.add(new TFieldOkTypeRule());
		rules.add(new TClassOkTypeRule());
		rules.add(new TProgramTypeRule());
		setRules(rules);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.IntConstant object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getIntConstant()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.IntConstant object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.IntConstant, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.IntConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getIntConstant()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.IntConstant, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.IntConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.IntConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getIntConstant()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.IntConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.StringConstant object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getStringConstant()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.StringConstant object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.StringConstant, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.StringConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getStringConstant()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.StringConstant, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.StringConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.StringConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getStringConstant()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.StringConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.BoolConstant object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getBoolConstant()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.BoolConstant object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.BoolConstant, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.BoolConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getBoolConstant()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.BoolConstant, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.BoolConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.BoolConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getBoolConstant()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.BoolConstant left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.This object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getThis()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.This object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.This, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.This left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getThis()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.This, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.This left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.This left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getThis()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.This left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Parameter object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getParameter()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.Parameter object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Parameter, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Parameter left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getParameter()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Parameter, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.Parameter left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Parameter left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getParameter()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Parameter left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.ParamRef object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getVariable()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.ParamRef object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.ParamRef, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.ParamRef left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getVariable()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.ParamRef, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.ParamRef left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.ParamRef left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getVariable()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.ParamRef left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Field object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getField()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.Field object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Field, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Field left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getField()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Field, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.Field left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Field left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getField()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Field left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.MethodBody object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethodBody()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.MethodBody object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.MethodBody, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.MethodBody left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethodBody()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.MethodBody, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.MethodBody left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.MethodBody left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethodBody()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.MethodBody left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Expression object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getExpression()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.Expression object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Expression, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Expression left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getExpression()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Expression, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.Expression left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Expression left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getExpression()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Expression left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.New object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getNew()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.New object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.New, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.New left, it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getNew()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.New, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.New left, it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.New left, it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getNew()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.New left, it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Message object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMessage()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.Message object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Message, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Message left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getMessage()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Message, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.Message left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Message left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMessage()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Message left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.MethodCall object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethodCall()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.MethodCall object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.MethodCall, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.MethodCall left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethodCall()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.MethodCall, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.MethodCall left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.MethodCall left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethodCall()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.MethodCall left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.FieldSelection object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getFieldSelection()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.FieldSelection object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.FieldSelection, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.FieldSelection left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getFieldSelection()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.FieldSelection, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.FieldSelection left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.FieldSelection left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getFieldSelection()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.FieldSelection left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Selection object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getSelection()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.Selection object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Selection, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Selection left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getSelection()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Selection, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.Selection left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Selection left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getSelection()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Selection left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Cast object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getCast()),
				createEClassifierType(basicPackage.getType()), object);
	}

	public TypeSystemResult<it.xsemantics.example.fj.fj.Type> typeAsType(
			it.xsemantics.example.fj.fj.Cast object) {
		return typeAsType(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Cast, it.xsemantics.example.fj.fj.Type> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Cast left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getCast()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Cast, it.xsemantics.example.fj.fj.Type> type(
			it.xsemantics.example.fj.fj.Cast left,
			it.xsemantics.example.fj.fj.Type right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Cast left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getCast()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Cast left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<String> typeAsString(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Method object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethod()),
				createBasicType("String"), object);
	}

	public TypeSystemResult<String> typeAsString(
			it.xsemantics.example.fj.fj.Method object) {
		return typeAsString(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Method, String> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Method left, String right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethod()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Method, String> type(
			it.xsemantics.example.fj.fj.Method left, String right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Method left, String right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getMethod()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Method left, String right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<String> typeAsString(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Field object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getField()),
				createBasicType("String"), object);
	}

	public TypeSystemResult<String> typeAsString(
			it.xsemantics.example.fj.fj.Field object) {
		return typeAsString(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Field, String> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Field left, String right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getField()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Field, String> type(
			it.xsemantics.example.fj.fj.Field left, String right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Field left, String right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getField()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Field left, String right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<String> typeAsString(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Class object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getClass_()),
				createBasicType("String"), object);
	}

	public TypeSystemResult<String> typeAsString(
			it.xsemantics.example.fj.fj.Class object) {
		return typeAsString(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Class, String> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Class left, String right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getClass_()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Class, String> type(
			it.xsemantics.example.fj.fj.Class left, String right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Class left, String right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getClass_()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Class left, String right) {
		return checkType(null, left, right);
	}

	public TypeSystemResult<String> typeAsString(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Program object) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getProgram()),
				createBasicType("String"), object);
	}

	public TypeSystemResult<String> typeAsString(
			it.xsemantics.example.fj.fj.Program object) {
		return typeAsString(null, object);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Program, String> type(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Program left, String right) {
		return tryToApplyPair(environment, "|-", ":",
				createEClassifierType(basicPackage.getProgram()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResultPair<it.xsemantics.example.fj.fj.Program, String> type(
			it.xsemantics.example.fj.fj.Program left, String right) {
		return type(null, left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Program left, String right) {
		return tryToApply(environment, "|-", ":",
				createEClassifierType(basicPackage.getProgram()),
				createBasicType("String"), left, right);
	}

	public TypeSystemResult<Boolean> checkType(
			it.xsemantics.example.fj.fj.Program left, String right) {
		return checkType(null, left, right);
	}

	public RuntimeRule applyTypeRule(TypingJudgmentEnvironment environment,
			Object left, Object right) throws RuleFailedException {
		return applyRule(environment, "|-", ":", left, right);
	}

	public RuntimeRule applyTypeRule(Object left, Object right)
			throws RuleFailedException {
		return applyTypeRule(null, left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Class left,
			it.xsemantics.example.fj.fj.Class right) {
		return tryToApply(environment, "|-", "<:",
				createEClassifierType(basicPackage.getClass_()),
				createEClassifierType(basicPackage.getClass_()), left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			it.xsemantics.example.fj.fj.Class left,
			it.xsemantics.example.fj.fj.Class right) {
		return checkSubtype(null, left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Type left,
			it.xsemantics.example.fj.fj.Type right) {
		return tryToApply(environment, "|-", "<:",
				createEClassifierType(basicPackage.getType()),
				createEClassifierType(basicPackage.getType()), left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			it.xsemantics.example.fj.fj.Type left,
			it.xsemantics.example.fj.fj.Type right) {
		return checkSubtype(null, left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.ClassType left,
			it.xsemantics.example.fj.fj.ClassType right) {
		return tryToApply(environment, "|-", "<:",
				createEClassifierType(basicPackage.getClassType()),
				createEClassifierType(basicPackage.getClassType()), left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			it.xsemantics.example.fj.fj.ClassType left,
			it.xsemantics.example.fj.fj.ClassType right) {
		return checkSubtype(null, left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.BasicType left,
			it.xsemantics.example.fj.fj.BasicType right) {
		return tryToApply(environment, "|-", "<:",
				createEClassifierType(basicPackage.getBasicType()),
				createEClassifierType(basicPackage.getBasicType()), left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			it.xsemantics.example.fj.fj.BasicType left,
			it.xsemantics.example.fj.fj.BasicType right) {
		return checkSubtype(null, left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			TypingJudgmentEnvironment environment,
			java.util.List<it.xsemantics.example.fj.fj.Expression> left,
			java.util.List<it.xsemantics.example.fj.fj.Parameter> right) {
		return tryToApply(environment, "|-", "<:",
				createCollectionType(createEClassifierType(basicPackage
						.getExpression())),
				createCollectionType(createEClassifierType(basicPackage
						.getParameter())), left, right);
	}

	public TypeSystemResult<Boolean> checkSubtype(
			java.util.List<it.xsemantics.example.fj.fj.Expression> left,
			java.util.List<it.xsemantics.example.fj.fj.Parameter> right) {
		return checkSubtype(null, left, right);
	}

	public RuntimeRule applySubtypeRule(TypingJudgmentEnvironment environment,
			Object left, Object right) throws RuleFailedException {
		return applyRule(environment, "|-", "<:", left, right);
	}

	public RuntimeRule applySubtypeRule(Object left, Object right)
			throws RuleFailedException {
		return applySubtypeRule(null, left, right);
	}

	public TypeSystemResult<Boolean> checkOverride(
			TypingJudgmentEnvironment environment,
			it.xsemantics.example.fj.fj.Method left,
			it.xsemantics.example.fj.fj.Method right) {
		return tryToApply(environment, "|-", "~",
				createEClassifierType(basicPackage.getMethod()),
				createEClassifierType(basicPackage.getMethod()), left, right);
	}

	public TypeSystemResult<Boolean> checkOverride(
			it.xsemantics.example.fj.fj.Method left,
			it.xsemantics.example.fj.fj.Method right) {
		return checkOverride(null, left, right);
	}

	public RuntimeRule applyOverrideRule(TypingJudgmentEnvironment environment,
			Object left, Object right) throws RuleFailedException {
		return applyRule(environment, "|-", "~", left, right);
	}

	public RuntimeRule applyOverrideRule(Object left, Object right)
			throws RuleFailedException {
		return applyOverrideRule(null, left, right);
	}

}