import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
/**
 * Returns false if the argument expression is a lambda and the expected type
 * of the argument is not a function type or {@link Object}.
 * Returns true in all other cases.
 * 
 * This serves as a shortcut to rule out decision path's where a method is overloaded
 * and one of the overloads accepts a function type but the other doesn't. In those cases
 * it is not necessary to compute the type of the lamdba expression twice.
 * 
 * An example for this pattern is {@link IterableExtensions#filter(Iterable, Class)} vs
 * {@link IterableExtensions#filter(Iterable, org.eclipse.xtext.xbase.lib.Functions.Function1)}.
 */
protected boolean isPossibleFunctionType(int idx) {
	if (idx < arguments.getArgumentCount()) {
		XExpression argument = arguments.getArgument(idx);
		if (argument instanceof XClosure) {
			XClosure closure = (XClosure) argument;
			LightweightTypeReference declaredType = arguments.getDeclaredTypeForLambda(idx);
			if (declaredType != null && !declaredType.isType(Object.class)) {
				CommonTypeComputationServices services = getState().getReferenceOwner().getServices();
				JvmOperation operation = services.getFunctionTypes().findImplementingOperation(declaredType);
				if (operation == null) {
					return false;
				}
				if (closure.isExplicitSyntax() && closure.getDeclaredFormalParameters().size() != operation.getParameters().size()) {
					return false;
				}
			}
		}
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean isXShortClosure(List<?> values, EReference reference, INodesForEObjectProvider nodes) {
	if (values.isEmpty() || values.size() > 2 || !(values.get(0) instanceof XClosure))
		return false;
	XClosure closure = (XClosure) values.get(0);
	if (!closure.isExplicitSyntax())
		return false;
	INode node = nodes.getNodeForMultiValue(reference, 0, 0, closure);
	if (node != null) {
		if (node.getGrammarElement() instanceof RuleCall)
			return ((RuleCall) node.getGrammarElement()).getRule() == grammarAccess.getXShortClosureRule();
		if (node.getGrammarElement() instanceof Action)
			return node.getGrammarElement() == grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0();
		return false;
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean isBuilderSyntax(List<?> values, EReference reference, INodesForEObjectProvider nodes) {
	if (values.isEmpty())
		return false;
	int lastIndex = values.size() - 1;
	Object lastValue = values.get(lastIndex);
	if (!(lastValue instanceof XClosure))
		return false;
	INode node = nodes.getNodeForMultiValue(reference, lastIndex, lastIndex, values.get(lastIndex));
	if (node != null) {
		if (node.getGrammarElement() instanceof RuleCall)
			return ((RuleCall) node.getGrammarElement()).getRule() == grammarAccess.getXClosureRule();
		if (node.getGrammarElement() instanceof Action) 
			return node.getGrammarElement() == grammarAccess.getXClosureAccess().getXClosureAction_0_0_0();
		return false;
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean bracesAreAddedByOuterStructure(XExpression expression) {
	EObject container = expression.eContainer();
	if (container instanceof XTryCatchFinallyExpression 
			|| container instanceof XIfExpression
			|| container instanceof XClosure
			|| container instanceof XSynchronizedExpression) {
		return true;
	}
	if (container instanceof XBlockExpression) {
		XBlockExpression blockExpression = (XBlockExpression) container;
		EList<XExpression> expressions = blockExpression.getExpressions();
		if (expressions.size() == 1 && expressions.get(0) == expression) {
			return bracesAreAddedByOuterStructure(blockExpression);
		}
	}
	if (!(container instanceof XExpression)) {
		return true;
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected void _toJavaStatement(final XClosure closure, final ITreeAppendable b, boolean isReferenced) {
	if (!isReferenced)
		throw new IllegalArgumentException("a closure definition does not cause any side-effects");
	LightweightTypeReference type = getLightweightType(closure);
	JvmOperation operation = findImplementingOperation(type);
	if (operation != null) {
		b.newLine().append("final ");
		b.append(type);
		b.append(" ");
		String variableName = b.declareSyntheticVariable(closure, "_function");
		b.append(variableName).append(" = ");
		GeneratorConfig config = b.getGeneratorConfig();
		if (config != null && config.getJavaSourceVersion().isAtLeast(JAVA8) && canCompileToJavaLambda(closure, type, operation)) {
			toLambda(closure, b, type, operation, false);
		} else {
			toAnonymousClass(closure, b, type, operation);
		}
		b.append(";");
	}
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected void _toJavaExpression(final XClosure closure, final ITreeAppendable b) {
	if (b.hasName(closure)) {
		b.trace(closure, false).append(getVarName(closure, b));
	} else {
		LightweightTypeReference type = getLightweightType(closure);
		JvmOperation operation = findImplementingOperation(type);
		if (operation != null) {
			GeneratorConfig config = b.getGeneratorConfig();
			if (config != null && config.getJavaSourceVersion().isAtLeast(JAVA8) && canCompileToJavaLambda(closure, type, operation)) {
				toLambda(closure, b.trace(closure, false), type, operation, true);
			} else {
				toAnonymousClass(closure, b.trace(closure, false), type, operation);
			}
		}
	}
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean canCompileToJavaLambda(XClosure closure, LightweightTypeReference typeRef, JvmOperation operation) {
	if (!typeRef.isInterfaceType())
		return false;
	
	if (!operation.getTypeParameters().isEmpty())
		return false;
	
	TreeIterator<EObject> iterator = closure.eAllContents();
	JvmType jvmType = typeRef.getType();
	while (iterator.hasNext()) {
		EObject obj = iterator.next();
		if (obj instanceof XClosure) {
			iterator.prune();
		} else if (obj instanceof XFeatureCall && isReferenceToSelf((XFeatureCall) obj, jvmType)) {
			return false;
		}
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected XClosure builder(final List<XExpression> params) {
  XClosure _xifexpression = null;
  XExpression _last = IterableExtensions.<XExpression>last(params);
  boolean _tripleNotEquals = (_last != null);
  if (_tripleNotEquals) {
    XClosure _xblockexpression = null;
    {
      final EObject grammarElement = this.textRegionExtensions.grammarElement(IterableExtensions.<XExpression>last(params));
      XClosure _xifexpression_1 = null;
      if (((Objects.equal(grammarElement, this.grammar.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()) || 
        Objects.equal(grammarElement, this.grammar.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0())) || 
        Objects.equal(grammarElement, this.grammar.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()))) {
        XExpression _last_1 = IterableExtensions.<XExpression>last(params);
        _xifexpression_1 = ((XClosure) _last_1);
      }
      _xblockexpression = _xifexpression_1;
    }
    _xifexpression = _xblockexpression;
  }
  return _xifexpression;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected Iterable<XExpression> explicitParams(final List<XExpression> params) {
  Iterable<XExpression> _xblockexpression = null;
  {
    final XClosure builder = this.builder(params);
    Iterable<XExpression> _xifexpression = null;
    if ((builder != null)) {
      int _size = params.size();
      int _minus = (_size - 1);
      _xifexpression = IterableExtensions.<XExpression>take(params, _minus);
    } else {
      _xifexpression = params;
    }
    _xblockexpression = _xifexpression;
  }
  return _xblockexpression;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean prependNewLineIfMultiline(final EObject obj) {
  boolean _switchResult = false;
  boolean _matched = false;
  if (obj instanceof XMemberFeatureCall) {
    _matched=true;
    _switchResult = this.prependNewLineIfMultiline(this.builder(((XMemberFeatureCall)obj).getMemberCallArguments()));
  }
  if (!_matched) {
    if (obj instanceof XClosure) {
      _matched=true;
      _switchResult = false;
    }
  }
  if (!_matched) {
    if (obj instanceof XBlockExpression) {
      _matched=true;
      _switchResult = false;
    }
  }
  if (!_matched) {
    _switchResult = true;
  }
  return _switchResult;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected XClosure builder(final List<XExpression> params) {
  XClosure _xifexpression = null;
  XExpression _last = IterableExtensions.<XExpression>last(params);
  boolean _tripleNotEquals = (_last != null);
  if (_tripleNotEquals) {
    XClosure _xblockexpression = null;
    {
      INode _nodeForEObject = this._nodeModelAccess.nodeForEObject(IterableExtensions.<XExpression>last(params));
      final EObject grammarElement = ((ICompositeNode) _nodeForEObject).getFirstChild().getGrammarElement();
      XClosure _xifexpression_1 = null;
      if (((Objects.equal(grammarElement, this._xbaseGrammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()) || 
        Objects.equal(grammarElement, this._xbaseGrammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0())) || 
        Objects.equal(grammarElement, this._xbaseGrammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()))) {
        XExpression _last_1 = IterableExtensions.<XExpression>last(params);
        _xifexpression_1 = ((XClosure) _last_1);
      }
      _xblockexpression = _xifexpression_1;
    }
    _xifexpression = _xblockexpression;
  }
  return _xifexpression;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
/**
 * checks whether the given lambda should be formatted as a block.
 * That includes newlines after and before the brackets, and a fresh line for each expression.
 */
protected boolean isMultilineLambda(final XClosure closure) {
  final ILeafNode closingBracket = this._nodeModelAccess.nodeForKeyword(closure, "]");
  HiddenLeafs _hiddenLeafsBefore = null;
  if (closingBracket!=null) {
    _hiddenLeafsBefore=this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket);
  }
  boolean _tripleNotEquals = (_hiddenLeafsBefore != null);
  if (_tripleNotEquals) {
    int _newLines = this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket).getNewLines();
    return (_newLines > 0);
  }
  boolean _switchResult = false;
  XExpression _expression = closure.getExpression();
  final XExpression block = _expression;
  boolean _matched = false;
  if (block instanceof XBlockExpression) {
    _matched=true;
    _switchResult = ((((XBlockExpression)block).getExpressions().size() > 1) && this.isEachExpressionInOwnLine(((XBlockExpression)block).getExpressions()));
  }
  if (!_matched) {
    _switchResult = false;
  }
  return _switchResult;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Test
	public void testClosureParameter() throws Exception {
//		List<? super String> list = Lists.newArrayList();
//		ListExtensions.map(list, new Functions.Function1<CharSequence, String>() {
//			public String apply(CharSequence p) {
//				return null;
//			}
//		});
//		ListExtensions.map(list, new Functions.Function1<Object, String>() {
//			public String apply(Object p) {
//				return null;
//			}
//		});
		XBlockExpression block = (XBlockExpression) expression(
				"{\n" + 
				"  var java.util.List<? super String> list = null;\n" + 
				"  list.map(e|e)\n" +
				"}");
		XMemberFeatureCall featureCall = (XMemberFeatureCall) block.getExpressions().get(1);
		XClosure closure = (XClosure) featureCall.getMemberCallArguments().get(0);
		JvmFormalParameter e = closure.getDeclaredFormalParameters().get(0);
		LightweightTypeReference typeRef = typeResolver.resolveTypes(closure).getActualType(e);
		assertEquals("java.lang.Object", typeRef.getIdentifier());
	}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Test public void testSerialize_01() throws Exception {
	Resource resource = newResource("'foo' as String");
	XCastedExpression casted = (XCastedExpression) resource.getContents().get(0);
	
	XbaseFactory factory = XbaseFactory.eINSTANCE;
	XClosure closure = factory.createXClosure();
	XStringLiteral stringLiteral = factory.createXStringLiteral();
	stringLiteral.setValue("value");
	XBlockExpression blockExpression = factory.createXBlockExpression();
	blockExpression.getExpressions().add(stringLiteral);
	closure.setExpression(blockExpression);
	closure.setExplicitSyntax(true);
	XInstanceOfExpression instanceOfExpression = factory.createXInstanceOfExpression();
	instanceOfExpression.setExpression(closure);
	instanceOfExpression.setType(EcoreUtil.copy(casted.getType()));
	resource.getContents().clear();
	resource.getContents().add(instanceOfExpression);
	ISerializer serializer = get(ISerializer.class);
	String string = serializer.serialize(instanceOfExpression);
	assertEquals("[|\"value\"] instanceof String", string);
	
	XInstanceOfExpression parsedExpression = parseHelper.parse(string);
	assertTrue(EcoreUtil.equals(instanceOfExpression, parsedExpression));
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Check
public void checkClosureParameterTypes(XClosure closure) {
	if (closure.getFormalParameters().isEmpty())
		return;
	LightweightTypeReference closureType = getActualType(closure);
	if (closureType != null && closureType.isUnknown())
		return;
	boolean checkedClosure = false;
	for (JvmFormalParameter p : closure.getFormalParameters()) {
		if (p.getParameterType() == null) {
			if (!checkedClosure) {
				LightweightTypeReference type = getExpectedType(closure);
				if (type == null) {
					error("There is no context to infer the closure's argument types from. Consider typing the arguments or put the closures into a typed context.",
							closure, null, INSIGNIFICANT_INDEX, TOO_LITTLE_TYPE_INFORMATION);
					return;
				} else {
					JvmOperation operation = getServices().getFunctionTypes().findImplementingOperation(type);
					if (operation == null) {
						error("There is no context to infer the closure's argument types from. Consider typing the arguments or use the closures in a more specific context.",
								closure, null, INSIGNIFICANT_INDEX, TOO_LITTLE_TYPE_INFORMATION);
						return;
					}
				}
				checkedClosure = true;
			}
			LightweightTypeReference parameterType = getActualType(closure, p);
			if (parameterType == null) {
				error("There is no context to infer the closure's argument types from. Consider typing the arguments or use the closures in a more specific context.",
						closure, null, INSIGNIFICANT_INDEX, TOO_LITTLE_TYPE_INFORMATION);
				return;
			}
		}
	}
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
private boolean isTypeParameterOfClosureImpl(JvmTypeReference ref) {
	JvmFormalParameter parameter = EcoreUtil2.getContainerOfType(ref, JvmFormalParameter.class);
	if (parameter != null) {
		return parameter.eContainer() instanceof XClosure;
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Check
public void checkClosureParams(XClosure closure) {
	if (closure.getDeclaredFormalParameters().size() > 6) {
		error("The maximum number of parameters for a closure is six.", closure,
				Literals.XCLOSURE__DECLARED_FORMAL_PARAMETERS, 6, TOO_MANY_PARAMS_IN_CLOSURE);
	}
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Override
protected boolean doValidateContents(EObject eObject, DiagnosticChain diagnostics, Map<Object, Object> context) {
	checkCanceled(context);
	if (eObject instanceof XClosure) {
		return doValidateLambdaContents((XClosure) eObject, diagnostics, context);
	}
	return super.doValidateContents(eObject, diagnostics, context);
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected void collectExits(EObject expr, List<XExpression> found) {
	if (expr instanceof XReturnExpression) {
		found.add((XExpression) expr);
	} else if (expr instanceof XThrowExpression) {
		found.add((XExpression) expr);
	} else if (expr instanceof XClosure) {
		return;
	}
	for (EObject child : expr.eContents()) {
		collectExits(child, found);
	}
}
 

import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Override
public List<JvmFormalParameter> getParameters() {
	XClosure closure = getClosure();
	if (closure.isExplicitSyntax()) {
		return closure.getDeclaredFormalParameters();
	}
	if (implicitParameters != null)
		return implicitParameters;
	return closure.getImplicitFormalParameters();
}