use of org.eclipse.xsemantics.runtime.RuleFailedException in project n4js by eclipse.
the class InternalTypeSystem method applyRuleExpectedTypeInAssignmentExpression.
protected Result<TypeRef> applyRuleExpectedTypeInAssignmentExpression(final RuleEnvironment G, final RuleApplicationTrace _trace_, final AssignmentExpression expr, final Expression operand) throws RuleFailedException {
// output parameter
TypeRef T = null;
/* { ! jsVariantHelper.isTypeAware(expr) if (operand===expr.lhs) { T = G.bottomTypeRef } else { T = G.topTypeRef } } or { DestructureUtils.isTopOfDestructuringAssignment(expr) if (operand===expr.lhs) { T = G.bottomTypeRef } else { T = G.topTypeRef } } or { expr.op===AssignmentOperator.ASSIGN; if (operand===expr.lhs) { T = G.bottomTypeRef } else { G |- expr.lhs : T } } or { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
{
RuleFailedException previousFailure = null;
try {
boolean _isTypeAware = this.jsVariantHelper.isTypeAware(expr);
boolean _not = (!_isTypeAware);
/* ! jsVariantHelper.isTypeAware(expr) */
if (!_not) {
sneakyThrowRuleFailedException("! jsVariantHelper.isTypeAware(expr)");
}
Expression _lhs = expr.getLhs();
boolean _tripleEquals = (operand == _lhs);
if (_tripleEquals) {
T = RuleEnvironmentExtensions.bottomTypeRef(G);
} else {
T = RuleEnvironmentExtensions.topTypeRef(G);
}
} catch (Exception e) {
previousFailure = extractRuleFailedException(e);
/* { DestructureUtils.isTopOfDestructuringAssignment(expr) if (operand===expr.lhs) { T = G.bottomTypeRef } else { T = G.topTypeRef } } or { expr.op===AssignmentOperator.ASSIGN; if (operand===expr.lhs) { T = G.bottomTypeRef } else { G |- expr.lhs : T } } or { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
{
try {
boolean _isTopOfDestructuringAssignment = DestructureUtils.isTopOfDestructuringAssignment(expr);
/* DestructureUtils.isTopOfDestructuringAssignment(expr) */
if (!_isTopOfDestructuringAssignment) {
sneakyThrowRuleFailedException("DestructureUtils.isTopOfDestructuringAssignment(expr)");
}
Expression _lhs_1 = expr.getLhs();
boolean _tripleEquals_1 = (operand == _lhs_1);
if (_tripleEquals_1) {
T = RuleEnvironmentExtensions.bottomTypeRef(G);
} else {
T = RuleEnvironmentExtensions.topTypeRef(G);
}
} catch (Exception e_1) {
previousFailure = extractRuleFailedException(e_1);
/* { expr.op===AssignmentOperator.ASSIGN; if (operand===expr.lhs) { T = G.bottomTypeRef } else { G |- expr.lhs : T } } or { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
{
try {
AssignmentOperator _op = expr.getOp();
boolean _tripleEquals_2 = (_op == AssignmentOperator.ASSIGN);
/* expr.op===AssignmentOperator.ASSIGN */
if (!_tripleEquals_2) {
sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ASSIGN");
}
Expression _lhs_2 = expr.getLhs();
boolean _tripleEquals_3 = (operand == _lhs_2);
if (_tripleEquals_3) {
T = RuleEnvironmentExtensions.bottomTypeRef(G);
} else {
/* G |- expr.lhs : T */
Expression _lhs_3 = expr.getLhs();
Result<TypeRef> result = typeInternal(G, _trace_, _lhs_3);
checkAssignableTo(result.getFirst(), TypeRef.class);
T = (TypeRef) result.getFirst();
}
} catch (Exception e_2) {
previousFailure = extractRuleFailedException(e_2);
/* { expr.op===AssignmentOperator.ADD_ASSIGN if (operand===expr.lhs) { T = TypeUtils.createNonSimplifiedIntersectionType(G.numberTypeRef, G.stringTypeRef); } else { G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef if (lhsTypeRef.declaredType === G.stringType) { T = G.anyTypeRef } else if(G.isNumeric(lhsTypeRef.declaredType)) { T = G.numberTypeRef } else { T = G.anyTypeRef } } } or { T = G.numberTypeRef } */
{
try {
AssignmentOperator _op_1 = expr.getOp();
boolean _tripleEquals_4 = (_op_1 == AssignmentOperator.ADD_ASSIGN);
/* expr.op===AssignmentOperator.ADD_ASSIGN */
if (!_tripleEquals_4) {
sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ADD_ASSIGN");
}
Expression _lhs_4 = expr.getLhs();
boolean _tripleEquals_5 = (operand == _lhs_4);
if (_tripleEquals_5) {
T = TypeUtils.createNonSimplifiedIntersectionType(RuleEnvironmentExtensions.numberTypeRef(G), RuleEnvironmentExtensions.stringTypeRef(G));
} else {
/* G |- expr.lhs : var ParameterizedTypeRef lhsTypeRef */
Expression _lhs_5 = expr.getLhs();
ParameterizedTypeRef lhsTypeRef = null;
Result<TypeRef> result_1 = typeInternal(G, _trace_, _lhs_5);
checkAssignableTo(result_1.getFirst(), ParameterizedTypeRef.class);
lhsTypeRef = (ParameterizedTypeRef) result_1.getFirst();
Type _declaredType = lhsTypeRef.getDeclaredType();
PrimitiveType _stringType = RuleEnvironmentExtensions.stringType(G);
boolean _tripleEquals_6 = (_declaredType == _stringType);
if (_tripleEquals_6) {
T = RuleEnvironmentExtensions.anyTypeRef(G);
} else {
boolean _isNumeric = RuleEnvironmentExtensions.isNumeric(G, lhsTypeRef.getDeclaredType());
if (_isNumeric) {
T = RuleEnvironmentExtensions.numberTypeRef(G);
} else {
T = RuleEnvironmentExtensions.anyTypeRef(G);
}
}
}
} catch (Exception e_3) {
previousFailure = extractRuleFailedException(e_3);
T = RuleEnvironmentExtensions.numberTypeRef(G);
}
}
}
}
}
}
}
}
return new Result<TypeRef>(T);
}
use of org.eclipse.xsemantics.runtime.RuleFailedException in project n4js by eclipse.
the class InternalTypeSystem method typeImpl.
protected Result<TypeRef> typeImpl(final RuleEnvironment G, final RuleApplicationTrace _trace_, final UnaryExpression e) throws RuleFailedException {
try {
final RuleApplicationTrace _subtrace_ = newTrace(_trace_);
final Result<TypeRef> _result_ = applyRuleTypeUnaryExpression(G, _subtrace_, e);
addToTrace(_trace_, new Provider<Object>() {
public Object get() {
return ruleName("typeUnaryExpression") + stringRepForEnv(G) + " |- " + stringRep(e) + " : " + stringRep(_result_.getFirst());
}
});
addAsSubtrace(_trace_, _subtrace_);
return _result_;
} catch (Exception e_applyRuleTypeUnaryExpression) {
typeThrowException(ruleName("typeUnaryExpression") + stringRepForEnv(G) + " |- " + stringRep(e) + " : " + "TypeRef", TYPEUNARYEXPRESSION, e_applyRuleTypeUnaryExpression, e, new ErrorInformation[] { new ErrorInformation(e) });
return null;
}
}
use of org.eclipse.xsemantics.runtime.RuleFailedException in project n4js by eclipse.
the class InternalTypeSystem method applyRuleTypeFormalParameter.
protected Result<TypeRef> applyRuleTypeFormalParameter(final RuleEnvironment G, final RuleApplicationTrace _trace_, final FormalParameter fpar) throws RuleFailedException {
// output parameter
TypeRef T = null;
final TypeRef fparTypeRef = fpar.getDeclaredTypeRef();
if ((fparTypeRef != null)) {
if (((fparTypeRef instanceof ThisTypeRefStructural) || ((fparTypeRef instanceof FunctionTypeExpression) && IteratorExtensions.<TFormalParameter>exists(Iterators.<TFormalParameter>filter(((FunctionTypeExpression) fparTypeRef).eAllContents(), TFormalParameter.class), ((Function1<TFormalParameter, Boolean>) (TFormalParameter currFpar) -> {
TypeRef _typeRef = currFpar.getTypeRef();
return Boolean.valueOf((_typeRef instanceof ThisTypeRef));
}))))) {
T = this.typeSystemHelper.bindAndSubstituteThisTypeRef(G, fparTypeRef, fparTypeRef);
} else {
TypeRef _xifexpression = null;
TFormalParameter _definedTypeElement = null;
if (fpar != null) {
_definedTypeElement = fpar.getDefinedTypeElement();
}
TypeRef _typeRef = null;
if (_definedTypeElement != null) {
_typeRef = _definedTypeElement.getTypeRef();
}
boolean _tripleNotEquals = (_typeRef != null);
if (_tripleNotEquals) {
_xifexpression = fpar.getDefinedTypeElement().getTypeRef();
} else {
_xifexpression = fpar.getDeclaredTypeRef();
}
T = _xifexpression;
}
} else {
boolean _isHasInitializerAssignment = fpar.isHasInitializerAssignment();
if (_isHasInitializerAssignment) {
Expression _initializer = fpar.getInitializer();
boolean _tripleNotEquals_1 = (_initializer != null);
if (_tripleNotEquals_1) {
/* G |- fpar.initializer : var TypeRef E */
Expression _initializer_1 = fpar.getInitializer();
TypeRef E = null;
Result<TypeRef> result = typeInternal(G, _trace_, _initializer_1);
checkAssignableTo(result.getFirst(), TypeRef.class);
E = (TypeRef) result.getFirst();
T = this.typeSystemHelper.sanitizeTypeOfVariableFieldProperty(G, E);
} else {
T = RuleEnvironmentExtensions.anyTypeRef(G);
}
} else {
boolean _enforceDynamicTypes = this.jsVariantHelper.enforceDynamicTypes(fpar);
if (_enforceDynamicTypes) {
T = RuleEnvironmentExtensions.anyTypeRefDynamic(G);
} else {
/* T = env(G, fpar, TypeRef) or T = G.anyTypeRef */
{
RuleFailedException previousFailure = null;
try {
T = this.<TypeRef>env(G, fpar, TypeRef.class);
} catch (Exception e) {
previousFailure = extractRuleFailedException(e);
T = RuleEnvironmentExtensions.anyTypeRef(G);
}
}
}
}
}
T = TypeUtils.wrapIfVariadic(RuleEnvironmentExtensions.getPredefinedTypes(G).builtInTypeScope, T, fpar);
return new Result<TypeRef>(T);
}
use of org.eclipse.xsemantics.runtime.RuleFailedException in project n4js by eclipse.
the class InternalTypeSystem method typeImpl.
protected Result<TypeRef> typeImpl(final RuleEnvironment G, final RuleApplicationTrace _trace_, final IndexedAccessExpression expr) throws RuleFailedException {
try {
final RuleApplicationTrace _subtrace_ = newTrace(_trace_);
final Result<TypeRef> _result_ = applyRuleTypeIndexedAccessExpression(G, _subtrace_, expr);
addToTrace(_trace_, new Provider<Object>() {
public Object get() {
return ruleName("typeIndexedAccessExpression") + stringRepForEnv(G) + " |- " + stringRep(expr) + " : " + stringRep(_result_.getFirst());
}
});
addAsSubtrace(_trace_, _subtrace_);
return _result_;
} catch (Exception e_applyRuleTypeIndexedAccessExpression) {
typeThrowException(ruleName("typeIndexedAccessExpression") + stringRepForEnv(G) + " |- " + stringRep(expr) + " : " + "TypeRef", TYPEINDEXEDACCESSEXPRESSION, e_applyRuleTypeIndexedAccessExpression, expr, new ErrorInformation[] { new ErrorInformation(expr) });
return null;
}
}
use of org.eclipse.xsemantics.runtime.RuleFailedException in project n4js by eclipse.
the class InternalTypeSystem method applyRuleTypeAssignmentExpression.
protected Result<TypeRef> applyRuleTypeAssignmentExpression(final RuleEnvironment G, final RuleApplicationTrace _trace_, final AssignmentExpression expr) throws RuleFailedException {
// output parameter
TypeRef T = null;
/* { expr.op===AssignmentOperator.ASSIGN; G |- expr.rhs: T } or { expr.op===AssignmentOperator.ADD_ASSIGN G |- expr.lhs: var ParameterizedTypeRef l G |- expr.rhs: var ParameterizedTypeRef r val lnum = l.declaredType == G.booleanType || G.isNumeric(l.declaredType); val rnum = r.declaredType == G.booleanType || G.isNumeric(r.declaredType); val undef = l.declaredType == G.undefinedType || l.declaredType == G.nullType || r.declaredType == G.undefinedType || r.declaredType == G.nullType; !(lnum && rnum); !(undef && (lnum || rnum)); T = G.stringTypeRef } or { T = G.numberTypeRef } */
{
RuleFailedException previousFailure = null;
try {
AssignmentOperator _op = expr.getOp();
boolean _tripleEquals = (_op == AssignmentOperator.ASSIGN);
/* expr.op===AssignmentOperator.ASSIGN */
if (!_tripleEquals) {
sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ASSIGN");
}
/* G |- expr.rhs: T */
Expression _rhs = expr.getRhs();
Result<TypeRef> result = typeInternal(G, _trace_, _rhs);
checkAssignableTo(result.getFirst(), TypeRef.class);
T = (TypeRef) result.getFirst();
} catch (Exception e) {
previousFailure = extractRuleFailedException(e);
/* { expr.op===AssignmentOperator.ADD_ASSIGN G |- expr.lhs: var ParameterizedTypeRef l G |- expr.rhs: var ParameterizedTypeRef r val lnum = l.declaredType == G.booleanType || G.isNumeric(l.declaredType); val rnum = r.declaredType == G.booleanType || G.isNumeric(r.declaredType); val undef = l.declaredType == G.undefinedType || l.declaredType == G.nullType || r.declaredType == G.undefinedType || r.declaredType == G.nullType; !(lnum && rnum); !(undef && (lnum || rnum)); T = G.stringTypeRef } or { T = G.numberTypeRef } */
{
try {
AssignmentOperator _op_1 = expr.getOp();
boolean _tripleEquals_1 = (_op_1 == AssignmentOperator.ADD_ASSIGN);
/* expr.op===AssignmentOperator.ADD_ASSIGN */
if (!_tripleEquals_1) {
sneakyThrowRuleFailedException("expr.op===AssignmentOperator.ADD_ASSIGN");
}
/* G |- expr.lhs: var ParameterizedTypeRef l */
Expression _lhs = expr.getLhs();
ParameterizedTypeRef l = null;
Result<TypeRef> result_1 = typeInternal(G, _trace_, _lhs);
checkAssignableTo(result_1.getFirst(), ParameterizedTypeRef.class);
l = (ParameterizedTypeRef) result_1.getFirst();
/* G |- expr.rhs: var ParameterizedTypeRef r */
Expression _rhs_1 = expr.getRhs();
ParameterizedTypeRef r = null;
Result<TypeRef> result_2 = typeInternal(G, _trace_, _rhs_1);
checkAssignableTo(result_2.getFirst(), ParameterizedTypeRef.class);
r = (ParameterizedTypeRef) result_2.getFirst();
final boolean lnum = (Objects.equal(l.getDeclaredType(), RuleEnvironmentExtensions.booleanType(G)) || RuleEnvironmentExtensions.isNumeric(G, l.getDeclaredType()));
final boolean rnum = (Objects.equal(r.getDeclaredType(), RuleEnvironmentExtensions.booleanType(G)) || RuleEnvironmentExtensions.isNumeric(G, r.getDeclaredType()));
final boolean undef = (((Objects.equal(l.getDeclaredType(), RuleEnvironmentExtensions.undefinedType(G)) || Objects.equal(l.getDeclaredType(), RuleEnvironmentExtensions.nullType(G))) || Objects.equal(r.getDeclaredType(), RuleEnvironmentExtensions.undefinedType(G))) || Objects.equal(r.getDeclaredType(), RuleEnvironmentExtensions.nullType(G)));
/* !(lnum && rnum) */
if (!(!(lnum && rnum))) {
sneakyThrowRuleFailedException("!(lnum && rnum)");
}
/* !(undef && (lnum || rnum)) */
if (!(!(undef && (lnum || rnum)))) {
sneakyThrowRuleFailedException("!(undef && (lnum || rnum))");
}
T = RuleEnvironmentExtensions.stringTypeRef(G);
} catch (Exception e_1) {
previousFailure = extractRuleFailedException(e_1);
T = RuleEnvironmentExtensions.numberTypeRef(G);
}
}
}
}
return new Result<TypeRef>(T);
}
Aggregations