import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
@Check
public void checkOperandTypesForTripleEquals(XBinaryOperation binaryOperation) {
	if(isTripleEqualsOperation(binaryOperation)){
		LightweightTypeReference left = getActualType(binaryOperation.getLeftOperand());
		LightweightTypeReference right = getActualType(binaryOperation.getRightOperand());
		if(left.isArray() != right.isArray()) {
			if (left.isArray()) {
				if (right.isAny() || right.isType(Object.class) || right.isType(Serializable.class) || right.isType(Cloneable.class)) {
					return;
				}
			} else {
				if (left.isAny() || left.isType(Object.class) || left.isType(Serializable.class) || left.isType(Cloneable.class)) {
					return;
				}
			}
			error("Incompatible operand types " + left.getHumanReadableName() + " and " + right.getHumanReadableName(), null, INVALID_OPERAND_TYPES);
		}
	}
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
public XExpression getSyntacticReceiver(XExpression expression) {
	if (expression instanceof XAbstractFeatureCall) {
		if (expression instanceof XFeatureCall) {
			return null;
		}
		if (expression instanceof XMemberFeatureCall) {
			return ((XMemberFeatureCall) expression).getMemberCallTarget();
		}
		if (expression instanceof XAssignment) {
			return ((XAssignment) expression).getAssignable();
		}
		if (expression instanceof XBinaryOperation) {
			return ((XBinaryOperation) expression).getLeftOperand();
		}
		if (expression instanceof XUnaryOperation) {
			return ((XUnaryOperation) expression).getOperand();
		}
		if (expression instanceof XPostfixOperation) {
			return ((XPostfixOperation) expression).getOperand();
		}
	}
	return null;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
public List<XExpression> getSyntacticArguments(XAbstractFeatureCall expression) {
	if (expression instanceof XFeatureCall) {
		return ((XFeatureCall) expression).getFeatureCallArguments();
	}
	if (expression instanceof XMemberFeatureCall) {
		return ((XMemberFeatureCall) expression).getMemberCallArguments();
	}
	if (expression instanceof XAssignment) {
		return Collections.singletonList(((XAssignment) expression).getValue());
	}
	if (expression instanceof XBinaryOperation) {
		return Collections.singletonList(((XBinaryOperation) expression).getRightOperand());
	}
	// explicit condition to make sure we thought about it
	if (expression instanceof XUnaryOperation) {
		return Collections.emptyList();
	}
	if (expression instanceof XPostfixOperation) {
		return Collections.emptyList();
	}
	return Collections.emptyList();
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
public Object internalEvaluate(final XExpression it, final Context ctx) {
  if (it instanceof XBinaryOperation) {
    return _internalEvaluate((XBinaryOperation)it, ctx);
  } else if (it instanceof XUnaryOperation) {
    return _internalEvaluate((XUnaryOperation)it, ctx);
  } else if (it instanceof XBooleanLiteral) {
    return _internalEvaluate((XBooleanLiteral)it, ctx);
  } else if (it instanceof XCastedExpression) {
    return _internalEvaluate((XCastedExpression)it, ctx);
  } else if (it instanceof XStringLiteral) {
    return _internalEvaluate((XStringLiteral)it, ctx);
  } else if (it instanceof XTypeLiteral) {
    return _internalEvaluate((XTypeLiteral)it, ctx);
  } else if (it instanceof XAnnotation) {
    return _internalEvaluate((XAnnotation)it, ctx);
  } else if (it != null) {
    return _internalEvaluate(it, ctx);
  } else if (it == null) {
    return _internalEvaluate((Void)null, ctx);
  } else {
    throw new IllegalArgumentException("Unhandled parameter types: " +
      Arrays.<Object>asList(it, ctx).toString());
  }
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
@Check
public void checkAssignment(XBinaryOperation binaryOperation) {
	if (binaryOperation.isReassignFirstArgument()) {
		XExpression leftOperand = binaryOperation.getLeftOperand();
		checkAssignment(leftOperand, false);
	}
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected boolean isReassignFirstArgument(XAbstractFeatureCall featureCall) {
	if (featureCall instanceof XBinaryOperation) {
		XBinaryOperation binaryOperation = (XBinaryOperation) featureCall;
		return binaryOperation.isReassignFirstArgument();	
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected boolean isOperationCallSyntax() {
	XAbstractFeatureCall featureCall = getFeatureCall();
	if (featureCall instanceof XBinaryOperation || featureCall instanceof XAssignment) {
		return false;
	}
	return featureCall.isExplicitOperationCallOrBuilderSyntax();
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected boolean isCompoundOperator() {
	if (!(getFeatureCall() instanceof XBinaryOperation)) {
		return false;
	}
	String methodName = getFeature().getSimpleName();
	return getState().getReferenceOwner().getServices().getOperatorMapping().isCompoundMethod(methodName);
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
@Override
protected String getSyntaxDescriptions() {
	XExpression expression = getExpression();
	if (expression instanceof XBinaryOperation) {
		return "binary operation";
	} else if (expression instanceof XUnaryOperation) {
		return "unary operation";
	} else if (expression instanceof XPostfixOperation) {
		return "postfix operation";
	} else {
		return "feature call";
	}
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected boolean validateTypeArgumentConformance(IAcceptor<? super AbstractDiagnostic> result) {
	if (getTypeArgumentConformanceFailures(result) == 0) {
		// TODO use early exit computation
		List<XExpression> arguments = getSyntacticArguments();
		for(int i = 0; i < arguments.size(); i++) {
			XExpression argument = arguments.get(i);
			if (isDefiniteEarlyExit(argument)) {
				XExpression errorOn = getExpression();
				String message = "Unreachable code.";
				EStructuralFeature errorFeature = null;
				if (i < arguments.size() - 1) {
					errorOn = arguments.get(i + 1);
				} else {
					errorFeature = getDefaultValidationFeature();
					if (errorOn instanceof XBinaryOperation) {
						message = "Unreachable code. The right argument expression does not complete normally.";
					} else {
						message = "Unreachable code. The last argument expression does not complete normally.";
					}
				}
				AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(
						Severity.ERROR, 
						IssueCodes.UNREACHABLE_CODE, 
						message, 
						errorOn, 
						errorFeature, 
						-1, null);
				result.accept(diagnostic);
				return false;
			}
		}
	} else {
		return false;
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected boolean startsWithUnaryOperator(EObject obj) {
	if(obj instanceof XUnaryOperation)
		return true;
	if(obj instanceof XBinaryOperation)
		return startsWithUnaryOperator(((XBinaryOperation)obj).getLeftOperand());
	if(obj instanceof XPostfixOperation) {
		return startsWithUnaryOperator(((XPostfixOperation)obj).getOperand());
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected QualifiedName getOperator(XAbstractFeatureCall call, QualifiedName name) {
	QualifiedName operator = operatorMapping.getOperator(name);
	if (!(call instanceof XBinaryOperation)) {
		return operator;
	}
	XBinaryOperation binaryOperation = (XBinaryOperation) call;
	if (!binaryOperation.isReassignFirstArgument()) {
		return operator;
	}
	if (operatorMapping.getCompoundOperators().contains(operator)) {
		return operator;
	}
	return operatorMapping.getCompoundOperator(operator);
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
@Override
public IScope getScope(EObject context, EReference reference) {
	if (context == null || context.eResource() == null || context.eResource().getResourceSet() == null) {
		return IScope.NULLSCOPE;
	}
	if (isFeatureCallScope(reference)) {
		IExpressionScope.Anchor anchor = IExpressionScope.Anchor.BEFORE;
		if (context instanceof XAbstractFeatureCall) {
			EObject proxyOrResolved = (EObject) context.eGet(reference, false);
			if (proxyOrResolved != null && !proxyOrResolved.eIsProxy()) {
				XExpression receiver = ((XAbstractFeatureCall) context).getActualReceiver();
				if (receiver == null && context instanceof XMemberFeatureCall) {
					receiver = ((XMemberFeatureCall) context).getMemberCallTarget();
				}
				if (receiver != null) {
					anchor = IExpressionScope.Anchor.RECEIVER;
					context = receiver;
				}
			} else if (context instanceof XBinaryOperation) {
				context = ((XBinaryOperation) context).getLeftOperand();
				anchor = IExpressionScope.Anchor.RECEIVER;
			} else if (context instanceof XMemberFeatureCall) {
				context = ((XMemberFeatureCall) context).getMemberCallTarget();
				anchor = IExpressionScope.Anchor.RECEIVER;
			}
		}
		IExpressionScope expressionScope = typeResolver.resolveTypes(context).getExpressionScope(context, anchor);
		return expressionScope.getFeatureScope();
	}
	if (isTypeScope(reference)) {
		return typeScopes.createTypeScope(context, reference);
	}
	return delegateGetScope(context, reference);
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
public boolean hasSideEffects(XAbstractFeatureCall featureCall, boolean inspectContents) {
	if (featureCall instanceof XBinaryOperation) {
		XBinaryOperation binaryOperation = (XBinaryOperation) featureCall;
		if (binaryOperation.isReassignFirstArgument()) {
			return true;
		}
	}
	if (featureCall instanceof XAssignment) {
		return true;
	}
	if (featureCall.isPackageFragment() || featureCall.isTypeLiteral()) {
		return false;
	}
	final JvmIdentifiableElement feature = featureCall.getFeature();
	if (feature == null || feature.eIsProxy())
		return true; // linking problems ... could be anything
	if (feature instanceof JvmConstructor) { //super() and this()
		return true;
	}
	if (feature instanceof JvmOperation) {
		JvmOperation jvmOperation = (JvmOperation) feature;
		if (findPureAnnotation(jvmOperation) == null) {
			return true;
		} else {
			if(inspectContents) {
				for (XExpression param : featureCall.getActualArguments()) {
					if (hasSideEffects(param))
						return true;
				}
			}
		}
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
public boolean isShortCircuitOperation(XAbstractFeatureCall featureCall) {
	if (featureCall instanceof XBinaryOperation) {
		if (isOperatorFromExtension(featureCall, OperatorMapping.ELVIS, ObjectExtensions.class))
			return true;
		else 
			return isBooleanAndOrOr(featureCall);
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected List<QualifiedName> getMethodNames(XAbstractFeatureCall featureCall, QualifiedName operatorSymbol) {
	List<QualifiedName> methodNames = new ArrayList<QualifiedName>();
	methodNames.add(operatorMapping.getMethodName(operatorSymbol));
	if (featureCall instanceof XBinaryOperation) {
		XBinaryOperation binaryOperation = (XBinaryOperation) featureCall;
		if (binaryOperation.isReassignFirstArgument()) {
			QualifiedName simpleOperator = operatorMapping.getSimpleOperator(operatorSymbol);
			if (simpleOperator != null) {
				methodNames.add(operatorMapping.getMethodName(simpleOperator));
			}
		}
	}
	return methodNames;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected ITreeAppendable appendLeftOperand(final XAbstractFeatureCall expr, ITreeAppendable appendable, boolean isExpressionContext) {
	XBinaryOperation binaryOperation = (XBinaryOperation) expr;
	XAbstractFeatureCall leftOperand = (XAbstractFeatureCall) binaryOperation.getLeftOperand();
	JvmIdentifiableElement feature = leftOperand.getFeature();
	if (appendable.hasName(feature)) {
		return appendable.append(appendable.getName(feature));
	}
	boolean hasReceiver = appendReceiver(leftOperand, appendable, isExpressionContext);
	if (hasReceiver) {
		appendable.append(".");
	}
	return appendable.append(feature.getSimpleName());
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected boolean needMultiAssignment(XAbstractFeatureCall expr) {
	if (expr instanceof XBinaryOperation) {
		XBinaryOperation binaryOperation = (XBinaryOperation) expr;
		return binaryOperation.isReassignFirstArgument();
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
protected void generateShortCircuitInvocation(final XAbstractFeatureCall featureCall, final ITreeAppendable b) {
	final XBinaryOperation binaryOperation = (XBinaryOperation) featureCall;
	final XExpression leftOperand = binaryOperation.getLeftOperand();
	final XExpression rightOperand = binaryOperation.getRightOperand();
	declareSyntheticVariable(binaryOperation, b);
	boolean isElvis = binaryOperation.getConcreteSyntaxFeatureName().equals(expressionHelper.getElvisOperator());
	prepareExpression(leftOperand, b);
	if(isElvis) {
		b.newLine().append("if (");
		toJavaExpression(leftOperand, b);
		b.append(" != null) {").increaseIndentation();
		b.newLine().append(b.getName(binaryOperation)).append(" = ");
		toJavaExpression(leftOperand, b);
		b.append(";");
	} else {
		b.newLine().append("if (");
		if (binaryOperation.getConcreteSyntaxFeatureName().equals(expressionHelper.getAndOperator())) {
			b.append("!");
		}
		toJavaExpression(leftOperand, b);
		b.append(") {").increaseIndentation();
		b.newLine().append(b.getName(binaryOperation)).append(" = ");
		b.append(Boolean.toString(binaryOperation.getConcreteSyntaxFeatureName().equals(expressionHelper.getOrOperator()))).append(";");
	}
	b.decreaseIndentation().newLine().append("} else {").increaseIndentation();
	if (binaryOperation.getImplicitReceiver() != null) {
		internalToJavaStatement(binaryOperation.getImplicitReceiver(), b, true);
	}
	prepareExpression(rightOperand, b);
	b.newLine().append(b.getName(binaryOperation)).append(" = ");
	toJavaExpression(rightOperand, b);
	b.append(";");
	b.decreaseIndentation().newLine().append("}");
}
 

import org.eclipse.xtext.xbase.XBinaryOperation; //导入依赖的package包/类
public EvaluationResult internalEvaluate(final XExpression it, final EvaluationContext context) {
  if (it instanceof XBinaryOperation) {
    return _internalEvaluate((XBinaryOperation)it, context);
  } else if (it instanceof XUnaryOperation) {
    return _internalEvaluate((XUnaryOperation)it, context);
  } else if (it instanceof XAbstractFeatureCall) {
    return _internalEvaluate((XAbstractFeatureCall)it, context);
  } else if (it instanceof XBooleanLiteral) {
    return _internalEvaluate((XBooleanLiteral)it, context);
  } else if (it instanceof XCastedExpression) {
    return _internalEvaluate((XCastedExpression)it, context);
  } else if (it instanceof XNullLiteral) {
    return _internalEvaluate((XNullLiteral)it, context);
  } else if (it instanceof XNumberLiteral) {
    return _internalEvaluate((XNumberLiteral)it, context);
  } else if (it instanceof XStringLiteral) {
    return _internalEvaluate((XStringLiteral)it, context);
  } else if (it instanceof XTypeLiteral) {
    return _internalEvaluate((XTypeLiteral)it, context);
  } else if (it != null) {
    return _internalEvaluate(it, context);
  } else if (it == null) {
    return _internalEvaluate((Void)null, context);
  } else {
    throw new IllegalArgumentException("Unhandled parameter types: " +
      Arrays.<Object>asList(it, context).toString());
  }
}