protected override Void handleYield(YieldStatementNode yield, Set <TypeInfo> dependencies)
{
if (yield.Value != null)
{
expressionHandler.handleExpression(yield.Value, dependencies, true);
}
return(null);
}
protected override Boolean handleYield(YieldStatementNode yield, HashSet <StatementNode> visited)
{
if (yield.Value != null)
{
expressionChecker.handleExpression(yield.Value, null, true);
return(Boolean.TRUE);
}
return(Boolean.FALSE);
}
protected override Void handleYield(YieldStatementNode yieldStatement, Void source)
{
var returnType = context.CodeValidationContext.CurrentMethod.ReturnType;
var value = yieldStatement.Value;
if (returnType == null)
{
if (value != null)
{
this.ExpressionValidator.handleExpression(value, returnType, true);
}
}
else
{
var elementType = BytecodeHelper.getIterableOrIteratorElementType(returnType);
if (elementType == null)
{
throw context.error(CompileErrorId.YieldOutsideIterator, yieldStatement);
}
if (value != null)
{
this.ExpressionValidator.handleExpression(value, elementType, true);
ValidationHelper.setBoxing(context, elementType, value);
if (!ValidationHelper.isAssignable(context, elementType, value))
{
throw context.error(CompileErrorId.NoImplicitConversion, value,
BytecodeHelper.getDisplayName(ValidationHelper.getType(context, value)),
BytecodeHelper.getDisplayName(elementType));
}
}
}
if (context.Iterables[context.CodeValidationContext.CurrentMethod] == null)
{
var prefix = "_" + context.CodeValidationContext.CurrentMethod.Name + "_Iterable";
int n = context.CurrentType.NestedTypes.count(p => p.Name.startsWith(prefix));
var typeBuilder = ((TypeBuilder)context.CurrentType).defineNestedType(prefix + n);
typeBuilder.setSourceFile(PathHelper.getFileName(yieldStatement.Filename));
typeBuilder.setSynthetic(true);
typeBuilder.setSuper(true);
context.Iterables[context.CodeValidationContext.CurrentMethod] = typeBuilder;
context.TypeBuilders.add(typeBuilder);
typeBuilder.setBaseType(context.TypeSystem.ObjectType);
}
return(null);
}
