import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
@Override
protected int getConformanceFlags(int idx, boolean recompute) {
	if (isStatic()) {
		if (idx == -1) {
			return ConformanceFlags.CHECKED_SUCCESS;
		}
	}
	if (idx == 0) {
		if (getReceiver() != null) {
			int result = getReceiverConformanceFlags();
			return result;
		}
	} else if (idx == 1) {
		if (getExpression() instanceof XAssignment && getFeature() instanceof JvmField) {
			return super.getConformanceFlags(0, recompute);
		}
	}
	return super.getConformanceFlags(idx, recompute);
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的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.XAssignment; //导入依赖的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.XAssignment; //导入依赖的package包/类
/**
 * Considers the given name to be a property name. If the concrete syntax of the
 * processed feature matches a feature call or assignment, a prefix is added to the
 * name and that one is used as a variant that should be processed. 
 */
protected void processAsPropertyNames(QualifiedName name, NameAcceptor acceptor) {
	String nameAsPropertyName = tryGetAsPropertyName(name.toString());
	if (nameAsPropertyName != null) {
		if (featureCall == null || featureCall instanceof XAssignment) {
			String aliasedSetter = "set" + nameAsPropertyName;
			acceptor.accept(aliasedSetter, 2);
		}
		if (!(featureCall instanceof XAssignment)) {
			if (featureCall == null || !getFeatureCall().isExplicitOperationCallOrBuilderSyntax()) {
				String aliasedGetter = "get" + nameAsPropertyName;
				acceptor.accept(aliasedGetter, 2);
				String aliasedBooleanGetter = "is" + nameAsPropertyName;
				acceptor.accept(aliasedBooleanGetter, 2);
			}
		}
	}
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
protected void featureCalltoJavaExpression(final XAbstractFeatureCall call, ITreeAppendable b, boolean isExpressionContext) {
	if (call instanceof XAssignment) {
		assignmentToJavaExpression((XAssignment) call, b, isExpressionContext);
	} else {
		if (needMultiAssignment(call)) {
			appendLeftOperand(call, b, isExpressionContext).append(" = ");
		}
		final JvmAnnotationReference annotationRef = this.expressionHelper.findInlineAnnotation(call);
		if (annotationRef == null || !isConstantExpression(annotationRef)) {
			boolean hasReceiver = appendReceiver(call, b, isExpressionContext);
			if (hasReceiver) {
				b.append(".");
				b = appendTypeArguments(call, b);
			}
		}
		appendFeatureCall(call, b);
	}
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
public IFeatureCallArguments createExpressionArguments(XExpression expression, AbstractLinkingCandidate<?> candidate) {
	JvmIdentifiableElement feature = candidate.getFeature();
	if (feature instanceof JvmExecutable) {
		JvmExecutable executable = (JvmExecutable) feature;
		return createArgumentsForExecutable(executable.isVarArgs(), candidate.getArguments(), executable.getParameters(), candidate.hasReceiver(), candidate.getState().getReferenceOwner());
	} else {
		if (expression instanceof XAssignment) {
			XAssignment assignment = (XAssignment) expression;
			LightweightTypeReference featureType = candidate.getActualType(candidate.getFeature(), true);
			return new AssignmentFeatureCallArguments(assignment.getValue(), featureType);
		} else {
			return new StandardFeatureCallArguments(candidate.getArguments(), Collections.<JvmFormalParameter>emptyList(), candidate.hasReceiver(), candidate.getState().getReferenceOwner());
		}
	}
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
protected boolean mustDiscardRefinement() {
	Expression expression = getExpression();
	if (expression instanceof XAssignment) {
		JvmIdentifiableElement feature = getFeature();
		if (feature instanceof XVariableDeclaration) {
			return ((XVariableDeclaration) feature).isWriteable();
		}
		if (feature instanceof JvmField) {
			return !((JvmField) feature).isFinal();
		}
	}
	return false;
}
 

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

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

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
protected boolean isAssignmentOrMemberFeatureCall() {
	if (getImplicitReceiverType() != null)
		return true;
	XAbstractFeatureCall featureCall = getFeatureCall();
	if (featureCall instanceof XAssignment) {
		return isSimpleAssignment((XAssignment) featureCall);
	}
	return featureCall instanceof XMemberFeatureCall;
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
@Override
protected CandidateCompareResult compareByArgumentTypes(AbstractPendingLinkingCandidate<?> right, boolean recompute) {
	CandidateCompareResult result = super.compareByArgumentTypes(right, recompute);
	if (result == CandidateCompareResult.AMBIGUOUS && getExpression() instanceof XAssignment) {
		if (description.isValidStaticState() == right.description.isValidStaticState()) {
			if (getFeature() instanceof JvmExecutable != right.getFeature() instanceof JvmExecutable) {
				if (getFeature() instanceof JvmExecutable) {
					return CandidateCompareResult.OTHER;
				}
				return CandidateCompareResult.THIS;
			}
		}
	}
	return result;
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
protected CandidateCompareResult compareByAssignmentName(AbstractPendingLinkingCandidate<?> right) {
	if (getExpression() instanceof XAssignment) {
		if (isValidAssignmentName(description)) {
			if (!isValidAssignmentName(right.description)) {
				return CandidateCompareResult.THIS;
			}
		} else if (isValidAssignmentName(right.description)) {
			return CandidateCompareResult.OTHER;
		} else {
			return CandidateCompareResult.EQUALLY_INVALID;
		}
	}
	return CandidateCompareResult.AMBIGUOUS;
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
@Override
protected CandidateCompareResult compareByArityWith(AbstractPendingLinkingCandidate<?> right) {
	CandidateCompareResult result = super.compareByArityWith(right);
	if (result == CandidateCompareResult.AMBIGUOUS) {
		boolean isExecutable = getFeature() instanceof JvmExecutable;
		if (isExecutable != right.getFeature() instanceof JvmExecutable && isVisible() == right.isVisible() && isTypeLiteral() == right.isTypeLiteral()) {
			// XAssignments return true from #isExplicitOperationCall though they may link to
			// a field or local variable
			if (!(getExpression() instanceof XAssignment) && isExplicitOperationCall()) {
				if (isExecutable)
					return CandidateCompareResult.THIS;
				return CandidateCompareResult.OTHER;
			}
		} else if (getFeature() == right.getFeature() && right instanceof FeatureLinkingCandidate) {
			FeatureLinkingCandidate casted = (FeatureLinkingCandidate) right;
			if (isStatic() && casted.isStatic()) {
				if (getImplicitReceiver() != casted.getImplicitReceiver()) {
					if (getImplicitReceiver() != null) {
						return CandidateCompareResult.OTHER;
					}
					return CandidateCompareResult.THIS;
				}
				// we link to identical static features with equal assumptions
				// stop comparison and take this one
				if (getReceiver() == casted.getReceiver() 
						&& isSyntacticReceiverPossibleArgument() == casted.isSyntacticReceiverPossibleArgument()) {
					return CandidateCompareResult.THIS; 
				}
			}
		}
	}
	return result;
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
/**
 * Returns the mismatch of actually given arguments and declared parameters.
 * Receivers and staticness of the feature is taken into account, too. The mismatch
 * may either be negative or positive.
 */
public int getArityMismatch() {
	JvmIdentifiableElement identifiable = getFeature();
	if (identifiable instanceof JvmExecutable) {
		return getArityMismatch((JvmExecutable) identifiable, getArguments());
	} else if (getExpression() instanceof XAssignment) {
		return getArguments().size() - 1;
	} else {
		return getArguments().size();
	}
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
@Override
protected List<INode> getLocationNodes(EObject obj) {
	if (obj instanceof XMemberFeatureCall || obj instanceof XAssignment || obj instanceof XFeatureCall) {
		List<INode> resultNodes = Lists.newArrayList();
		final ICompositeNode startNode = findNodeFor(obj);
		boolean crossRefConsumed = false;
		for (INode child : startNode.getChildren()) {
			if (crossRefConsumed) {
				resultNodes.add(child);
			} else {
				EObject grammarElement = child.getGrammarElement();
				if (grammarElement instanceof CrossReference) {
					// We don't use the grammar access to be more robust against
					// overwriting grammars
					Assignment assignment = GrammarUtil.containingAssignment(grammarElement);
					if (XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE.getName().equals(assignment.getFeature())) {
						crossRefConsumed = true;
						resultNodes.add(child);
					}
				}
			} 
		}
		if (!resultNodes.isEmpty())
			return resultNodes;
	}
	return super.getLocationNodes(obj);
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
protected boolean canBeLocalVariable() {
	XAbstractFeatureCall featureCall = getFeatureCall();
	if (featureCall != null) {
		return looksLikeLocalVariable(featureCall) || featureCall instanceof XAssignment;
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的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.XAssignment; //导入依赖的package包/类
protected Object _doEvaluate(XAssignment assignment, IEvaluationContext context, CancelIndicator indicator) {
	JvmIdentifiableElement feature = assignment.getFeature();
	if (feature instanceof JvmOperation && ((JvmOperation) feature).isVarArgs()) {
		return _doEvaluate((XAbstractFeatureCall) assignment, context, indicator);
	}
	Object value = internalEvaluate(assignment.getValue(), context, indicator);
	Object assign = assignValueTo(feature, assignment, value, context, indicator);
	return assign;
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
protected void completeXMemberFeatureCall(final EObject model, final Assignment assignment, final ContentAssistContext context, final IIdeContentProposalAcceptor acceptor) {
  if ((model instanceof XMemberFeatureCall)) {
    AbstractElement _terminal = assignment.getTerminal();
    this.createReceiverProposals(((XMemberFeatureCall)model).getMemberCallTarget(), 
      ((CrossReference) _terminal), context, acceptor);
  } else {
    if ((model instanceof XAssignment)) {
      AbstractElement _terminal_1 = assignment.getTerminal();
      this.createReceiverProposals(((XAssignment)model).getAssignable(), 
        ((CrossReference) _terminal_1), context, acceptor);
    }
  }
}
 

import org.eclipse.xtext.xbase.XAssignment; //导入依赖的package包/类
@Test public void testAssignment_rhs_01() throws Exception {
	String text = "a=b";
	XAssignment assignment = (XAssignment) expression(text);
	List<INode> nodesForFeature = NodeModelUtils.findNodesForFeature(assignment, XbasePackage.Literals.XASSIGNMENT__VALUE);
	assertEquals(1, nodesForFeature.size());
	String nodeText = nodesForFeature.get(0).getText();
	assertEquals("b", nodeText);
}