// NOTE: Specifically not overriding IsIndirectlyInIterator.
internal override TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
if (node != null)
{
diagnostics.Add(ErrorCode.ERR_YieldInAnonMeth, node.YieldKeyword.GetLocation());
}
return CreateErrorType();
}
private async Task<Document> MakeTaskYieldReturnStatements(Document document, YieldStatementSyntax yieldStatement, CancellationToken ct)
{
var root = await document.GetSyntaxRootAsync(ct).ConfigureAwait(false);
var semanticModel = await document.GetSemanticModelAsync(ct);
var nodes = yieldStatement.CreateFixedYieldReturn(semanticModel);
root = root.ReplaceNode(yieldStatement, nodes);
return document.WithSyntaxRoot(root);
}
public static void Go(OutputWriter writer, YieldStatementSyntax yieldStatementSyntax)
{
if (yieldStatementSyntax.ReturnOrBreakKeyword.IsKind(SyntaxKind.ReturnKeyword))
{
writer.WriteLine("__iter.yieldReturn({0});", Core.WriteString(yieldStatementSyntax.Expression));
}
else
{
writer.WriteLine("__iter.yieldBreak();");
}
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
var nextState = GetNextState(node);
if (node.ReturnOrBreakKeyword.IsKind(SyntaxKind.BreakKeyword))
{
currentState.Add(ChangeState(nextState));
currentState.Add(Cs.Return(Cs.False()));
}
else
{
currentState.Add(ChangeState(nextState));
currentState.Add(Cs.Express(Cs.This().Member("Current").Assign(StateMachineThisFixer.Fix(node.Expression))));
currentState.Add(Cs.Return(Cs.True()));
}
SetClosed(currentState);
currentState = nextState;
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
var nextState = GetNextState();
if (node.ReturnOrBreakKeyword.IsKind(SyntaxKind.BreakKeyword))
{
CurrentState.Add(ChangeState(nextState));
CurrentState.Add(Js.Primitive(false).Return());
}
else
{
CurrentState.Add(ChangeState(nextState));
// if (Transformer.Model.Compilation.Assembly.AreAutoPropertiesMinimized())
// CurrentState.Add(Js.Reference(stateMachine).Member("Current").Assign((JsExpression)node.Expression.Accept(Transformer)).Express());
// else
CurrentState.Add(Js.Reference(stateMachine).Member("set_Current").Invoke((JsExpression)node.Expression.Accept(Transformer)).Express());
CurrentState.Add(Js.Primitive(true).Return());
}
CurrentState = nextState;
}
/// <inheritdoc/>
public override void VisitYieldStatement(YieldStatementSyntax node)
{
this.yieldStatements.Add(node);
base.VisitYieldStatement(node);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
this.sawYield = true;
base.VisitYieldStatement(node);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
if (node.IsKind(SyntaxKind.YieldBreakStatement))
{
// end not connected with data
curNode = builder.CreateEndNode(node);
}
else {
CreateConnectedEndNode(node);
}
}
private BoundStatement BindYieldBreakStatement(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
if (this.Flags.Includes(BinderFlags.InFinallyBlock))
{
Error(diagnostics, ErrorCode.ERR_BadYieldInFinally, node.YieldKeyword);
}
GetIteratorElementType(node, diagnostics);
return new BoundYieldBreakStatement(node);
}
public override SyntaxNode VisitYieldStatement(YieldStatementSyntax node)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.YieldNotSupport);
return node;
}
internal override TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
if (IsScriptClass)
{
// This is the scenario where a `yield return` exists in the script file as a global statement.
// This method is to guard against hitting `BuckStopsHereBinder` and crash.
return this.Compilation.GetSpecialType(SpecialType.System_Object);
}
else
{
// This path would eventually throw, if we didn't have the case above.
return Next.GetIteratorElementType(node, diagnostics);
}
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
HasYieldStatement = true;
base.VisitYieldStatement(node);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
base.VisitYieldStatement(node);
isSpecial = true;
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
Emit("/*{0}*/", node.ToString());
base.VisitYieldStatement(node);
}
public override void VisitYieldStatement(YieldStatementSyntax node) => Fail = true;
public override void VisitYieldStatement(YieldStatementSyntax node)
{
VisitNodeToBind(node.Expression);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
Fail = true;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitYieldStatement(YieldStatementSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitYieldStatement(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitYieldStatement(YieldStatementSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitYieldStatement(node);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
LogUnsupportedSyntax(node);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
VisitNodeToBind(node.Expression);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
throw new NotSupportedException("Yield statement is not supported");
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
base.VisitYieldStatement(node);
_counter++;
}
private Block BuildYieldBreakStatement(YieldStatementSyntax yieldBreakStatement, Block currentBlock)
{
return(BuildJumpToExitStatement(yieldBreakStatement, currentBlock));
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
if (node.Expression != null)
{
var patternBinder = new PatternVariableBinder(node, _enclosing);
AddToMap(node, patternBinder);
Visit(node.Expression, patternBinder);
}
_sawYield = true;
}
public static bool IsYieldReturn(this YieldStatementSyntax node)
{
return(node.ReturnOrBreakKeyword.Text == "return");
}
internal override TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
TypeSymbol returnType = this.Owner.ReturnType;
if (!this.IsDirectlyInIterator)
{
// This should only happen when speculating, but we don't have a good way to assert that since the
// original binder isn't available here.
// If we're speculating about a yield statement inside a non-iterator method, we'll try to be nice
// and deduce an iterator element type from the return type. If we didn't do this, the
// TypeInfo.ConvertedType of the yield statement would always be an error type. However, we will
// not mutate any state (i.e. we won't store the result).
return GetIteratorElementTypeFromReturnType(returnType, node, diagnostics) ?? CreateErrorType();
}
if (this.iteratorInfo == IteratorInfo.Empty)
{
TypeSymbol elementType = null;
DiagnosticBag elementTypeDiagnostics = DiagnosticBag.GetInstance();
elementType = GetIteratorElementTypeFromReturnType(returnType, node, elementTypeDiagnostics);
if ((object)elementType == null)
{
Error(elementTypeDiagnostics, ErrorCode.ERR_BadIteratorReturn, this.Owner.Locations[0], this.Owner, returnType);
elementType = CreateErrorType();
}
var info = new IteratorInfo(elementType, elementTypeDiagnostics.ToReadOnlyAndFree());
Interlocked.CompareExchange(ref this.iteratorInfo, info, IteratorInfo.Empty);
}
if (node == null)
{
// node==null indicates this we are being called from the top-level of processing of a method. We report
// the diagnostic, if any, at that time to ensure it is reported exactly once.
diagnostics.AddRange(this.iteratorInfo.ElementTypeDiagnostics);
}
return this.iteratorInfo.ElementType;
}
public static bool IsYieldBreak(this YieldStatementSyntax node)
{
return(node.ReturnOrBreakKeyword == BreakKeyword);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
_sawYield = true;
base.VisitYieldStatement(node);
}
// This should only be called in the context of syntactically incorrect programs. In other
// contexts statements are surrounded by some enclosing method or lambda.
internal override TypeWithAnnotations GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
// There's supposed to be an enclosing method or lambda.
throw ExceptionUtilities.Unreachable;
}
internal override TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
diagnostics.Add(ErrorCode.ERR_IteratorInInteractive, node.Location);
return CreateErrorType();
}
private void BuildYieldBreakStatement(YieldStatementSyntax yieldBreakStatement)
{
BuildJumpToExitStatement(yieldBreakStatement);
}
public override Evaluation VisitYieldStatement(YieldStatementSyntax node)
{
node.Expression?.Accept <Evaluation>(this);
return(base.VisitYieldStatement(node));
}
public override object VisitYieldStatement(YieldStatementSyntax node)
{
expressionsVisitor.Visit(node.Expression);
return(null);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression,
RefactoringIdentifiers.AddCastExpression,
RefactoringIdentifiers.CallToMethod) &&
yieldStatement.IsYieldReturn() &&
yieldStatement.Expression != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ISymbol memberSymbol = ReturnExpressionRefactoring.GetContainingMethodOrPropertySymbol(yieldStatement.Expression, semanticModel, context.CancellationToken);
if (memberSymbol != null)
{
SyntaxNode node = await memberSymbol
.DeclaringSyntaxReferences[0]
.GetSyntaxAsync(context.CancellationToken)
.ConfigureAwait(false);
var containingMember = node as MemberDeclarationSyntax;
TypeSyntax memberType = ReturnExpressionRefactoring.GetMemberType(containingMember);
if (memberType != null)
{
ITypeSymbol memberTypeSymbol = semanticModel.GetTypeSymbol(memberType, context.CancellationToken);
if (memberTypeSymbol?.SpecialType != SpecialType.System_Collections_IEnumerable)
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(yieldStatement.Expression, context.CancellationToken);
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression) &&
typeSymbol?.IsErrorType() == false &&
!typeSymbol.IsVoid() &&
!memberSymbol.IsOverride &&
(memberTypeSymbol == null ||
memberTypeSymbol.IsErrorType() ||
!memberTypeSymbol.IsConstructedFromIEnumerableOfT() ||
!((INamedTypeSymbol)memberTypeSymbol).TypeArguments[0].Equals(typeSymbol)))
{
INamedTypeSymbol newTypeSymbol = semanticModel
.Compilation
.GetSpecialType(SpecialType.System_Collections_Generic_IEnumerable_T)
.Construct(typeSymbol);
TypeSyntax newType = newTypeSymbol.ToMinimalTypeSyntax(semanticModel, memberType.SpanStart);
context.RegisterRefactoring(
$"Change {ReturnExpressionRefactoring.GetText(containingMember)} type to '{SymbolDisplay.GetMinimalString(newTypeSymbol, semanticModel, memberType.SpanStart)}'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeAsync(
context.Document,
memberType,
newType,
cancellationToken));
});
}
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) &&
yieldStatement.Expression.Span.Contains(context.Span) &&
memberTypeSymbol?.IsNamedType() == true)
{
var namedTypeSymbol = (INamedTypeSymbol)memberTypeSymbol;
if (namedTypeSymbol.IsConstructedFromIEnumerableOfT())
{
ITypeSymbol argumentSymbol = namedTypeSymbol.TypeArguments[0];
if (argumentSymbol != typeSymbol)
{
ModifyExpressionRefactoring.ComputeRefactoring(
context,
yieldStatement.Expression,
argumentSymbol,
semanticModel);
}
}
}
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceStatementWithIfStatement) &&
context.Span.IsBetweenSpans(yieldStatement))
{
var refactoring = new ReplaceYieldStatementWithIfStatementRefactoring();
await refactoring.ComputeRefactoringAsync(context, yieldStatement).ConfigureAwait(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override void VisitYieldStatement(YieldStatementSyntax node)
{
throw new NotSupportedException("We do not support translation of yield statements!");
}
public YieldStatementTranslation(YieldStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Expression = syntax.Expression.Get<ExpressionTranslation>(this);
}
public void VisitYieldStatement(YieldStatementSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
_writer.WriteKeyword(PrinterKeyword.Yield);
_writer.WriteSpace();
switch (node.Kind)
{
case ReturnOrBreak.Break: _writer.WriteKeyword(PrinterKeyword.Break); break;
case ReturnOrBreak.Return: _writer.WriteKeyword(PrinterKeyword.Return); break;
default: throw ThrowHelper.InvalidEnumValue(node.Kind);
}
if (node.Expression != null)
{
_writer.WriteSpace();
node.Expression.Accept(this);
}
_writer.EndStatement();
WriteTrailingTrivia(node);
}
/// <inheritdoc />
/// <summary>
/// Called when the visitor visits a YieldStatementSyntax node.
/// </summary>
/// <param name="node">Visited node</param>
public override void VisitYieldStatement(YieldStatementSyntax node)
{
base.VisitYieldStatement(node);
counter_++;
}
public static Task <Document> RemoveParenthesesAsync(
Document document,
ParenthesizedExpressionSyntax parenthesizedExpression,
CancellationToken cancellationToken = default)
{
ExpressionSyntax expression = parenthesizedExpression.Expression;
SyntaxTriviaList leading = parenthesizedExpression.GetLeadingTrivia()
.Concat(parenthesizedExpression.OpenParenToken.TrailingTrivia)
.Concat(expression.GetLeadingTrivia())
.ToSyntaxTriviaList();
SyntaxTriviaList trailing = expression.GetTrailingTrivia()
.Concat(parenthesizedExpression.CloseParenToken.LeadingTrivia)
.Concat(parenthesizedExpression.GetTrailingTrivia())
.ToSyntaxTriviaList();
ExpressionSyntax newExpression = expression
.WithLeadingTrivia(leading)
.WithTrailingTrivia(trailing)
.WithFormatterAnnotation();
if (!leading.Any())
{
SyntaxNode parent = parenthesizedExpression.Parent;
switch (parent.Kind())
{
case SyntaxKind.ReturnStatement:
{
var returnStatement = (ReturnStatementSyntax)parent;
SyntaxToken returnKeyword = returnStatement.ReturnKeyword;
if (!returnKeyword.TrailingTrivia.Any())
{
ReturnStatementSyntax newNode = returnStatement.Update(returnKeyword.WithTrailingTrivia(Space), newExpression, returnStatement.SemicolonToken);
return(document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken));
}
break;
}
case SyntaxKind.YieldReturnStatement:
{
var yieldReturn = (YieldStatementSyntax)parent;
SyntaxToken returnKeyword = yieldReturn.ReturnOrBreakKeyword;
if (!returnKeyword.TrailingTrivia.Any())
{
YieldStatementSyntax newNode = yieldReturn.Update(yieldReturn.YieldKeyword, returnKeyword.WithTrailingTrivia(Space), newExpression, yieldReturn.SemicolonToken);
return(document.ReplaceNodeAsync(yieldReturn, newNode, cancellationToken));
}
break;
}
case SyntaxKind.AwaitExpression:
{
var awaitExpression = (AwaitExpressionSyntax)parent;
SyntaxToken awaitKeyword = awaitExpression.AwaitKeyword;
if (!awaitKeyword.TrailingTrivia.Any())
{
AwaitExpressionSyntax newNode = awaitExpression.Update(awaitKeyword.WithTrailingTrivia(Space), newExpression);
return(document.ReplaceNodeAsync(awaitExpression, newNode, cancellationToken));
}
break;
}
}
}
return(document.ReplaceNodeAsync(parenthesizedExpression, newExpression, cancellationToken));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CallToMethod) &&
yieldStatement.Kind() == SyntaxKind.YieldReturnStatement)
{
ExpressionSyntax expression = yieldStatement.Expression;
if (expression?.IsMissing == false &&
expression.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
(ISymbol memberSymbol, ITypeSymbol memberTypeSymbol) = ReturnExpressionRefactoring.GetContainingSymbolAndType(expression, semanticModel, context.CancellationToken);
if (memberSymbol != null &&
(memberTypeSymbol is INamedTypeSymbol namedTypeSymbol) &&
namedTypeSymbol.SpecialType != SpecialType.System_Collections_IEnumerable &&
namedTypeSymbol.OriginalDefinition.IsIEnumerableOfT())
{
ITypeSymbol argumentSymbol = namedTypeSymbol.TypeArguments[0];
ITypeSymbol expressionTypeSymbol = semanticModel.GetTypeSymbol(expression, context.CancellationToken);
if (!SymbolEqualityComparer.Default.Equals(argumentSymbol, expressionTypeSymbol))
{
ModifyExpressionRefactoring.ComputeRefactoring(
context,
expression,
argumentSymbol,
semanticModel,
addCastExpression: false);
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertReturnToIf) &&
(context.Span.IsEmptyAndContainedInSpan(yieldStatement.YieldKeyword) ||
context.Span.IsEmptyAndContainedInSpan(yieldStatement.ReturnOrBreakKeyword) ||
context.Span.IsBetweenSpans(yieldStatement)))
{
await ConvertReturnToIfRefactoring.ConvertYieldReturnToIfElse.ComputeRefactoringAsync(context, yieldStatement).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.UseListInsteadOfYield) &&
yieldStatement.IsYieldReturn() &&
context.Span.IsEmptyAndContainedInSpan(yieldStatement.YieldKeyword))
{
SyntaxNode declaration = yieldStatement.FirstAncestor(SyntaxKind.MethodDeclaration, SyntaxKind.LocalFunctionStatement, SyntaxKind.GetAccessorDeclaration, ascendOutOfTrivia: false);
Debug.Assert(declaration != null);
if (declaration != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
UseListInsteadOfYieldRefactoring.ComputeRefactoring(context, declaration, semanticModel);
}
}
}
protected override SyntaxNode VisitYieldStatement(YieldStatementSyntax node)
{
var expr = RewritePostfixUnarys (node.ExpressionOpt);
if (expr != node.ExpressionOpt)
node = node.Update (node.YieldKeyword, node.ReturnOrBreakKeyword, expr, node.SemicolonToken);
return base.VisitYieldStatement (node);
}
public YieldStatementTranslation(YieldStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Expression = syntax.Expression.Get <ExpressionTranslation>(this);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
mi.ExistYield = true;
if (node.ReturnOrBreakKeyword.Text == "return")
{
CodeBuilder.AppendFormat("{0}wrapyield(", GetIndentString());
if (null != node.Expression)
{
var type = m_Model.GetTypeInfoEx(node.Expression).Type;
OutputExpressionSyntax(node.Expression);
if (null != type && (IsImplementationOfSys(type, "IEnumerable") || IsImplementationOfSys(type, "IEnumerator")))
{
CodeBuilder.Append(", true");
}
else
{
CodeBuilder.Append(", false");
}
if (null != type && IsSubclassOf(type, "UnityEngine.YieldInstruction"))
{
CodeBuilder.Append(", true");
}
else
{
CodeBuilder.Append(", false");
}
}
else
{
CodeBuilder.Append("null, false, false");
}
CodeBuilder.Append(");");
CodeBuilder.AppendLine();
}
else
{
bool isLastNode = IsLastNodeOfParent(node);
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}block{{", GetIndentString());
CodeBuilder.AppendLine();
}
CodeBuilder.AppendFormat("{0}return(null);", GetIndentString());
CodeBuilder.AppendLine();
if (IsLastNodeOfMethod(node))
{
mi.ExistTopLevelReturn = true;
}
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}}};", GetIndentString());
CodeBuilder.AppendLine();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
/// tree by visiting the node.
/// </remarks>
public override void VisitYieldStatement(YieldStatementSyntax node)
{
this.VisitStatement(node);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, YieldStatementSyntax yieldStatement)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression,
RefactoringIdentifiers.AddCastExpression,
RefactoringIdentifiers.CallToMethod,
RefactoringIdentifiers.CreateConditionFromBooleanExpression) &&
yieldStatement.IsYieldReturn() &&
yieldStatement.Expression != null &&
context.SupportsSemanticModel)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression,
RefactoringIdentifiers.AddCastExpression,
RefactoringIdentifiers.CallToMethod))
{
MemberDeclarationSyntax containingMember = ReturnExpressionRefactoring.GetContainingMethodOrPropertyOrIndexer(yieldStatement.Expression);
if (containingMember != null)
{
TypeSyntax memberType = ReturnExpressionRefactoring.GetMemberType(containingMember);
if (memberType != null)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ITypeSymbol memberTypeSymbol = semanticModel
.GetTypeInfo(memberType, context.CancellationToken)
.Type;
if (memberTypeSymbol?.SpecialType != SpecialType.System_Collections_IEnumerable)
{
ITypeSymbol typeSymbol = semanticModel
.GetTypeInfo(yieldStatement.Expression, context.CancellationToken)
.Type;
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ChangeMemberTypeAccordingToYieldReturnExpression) &&
typeSymbol?.IsErrorType() == false &&
(memberTypeSymbol == null ||
memberTypeSymbol.IsErrorType() ||
!SyntaxAnalyzer.IsGenericIEnumerable(memberTypeSymbol) ||
!((INamedTypeSymbol)memberTypeSymbol).TypeArguments[0].Equals(typeSymbol)))
{
TypeSyntax newType = QualifiedName(
ParseName("System.Collections.Generic"),
GenericName(
Identifier("IEnumerable"),
TypeArgumentList(
SingletonSeparatedList(
CSharpFactory.Type(typeSymbol)))));
context.RegisterRefactoring(
$"Change {ReturnExpressionRefactoring.GetText(containingMember)} type to 'IEnumerable<{typeSymbol.ToDisplayString(SyntaxUtility.DefaultSymbolDisplayFormat)}>'",
cancellationToken =>
{
return(ChangeTypeRefactoring.ChangeTypeAsync(
context.Document,
memberType,
newType,
cancellationToken));
});
}
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.AddCastExpression, RefactoringIdentifiers.CallToMethod) &&
yieldStatement.Expression.Span.Contains(context.Span) &&
memberTypeSymbol?.IsNamedType() == true)
{
var namedTypeSymbol = (INamedTypeSymbol)memberTypeSymbol;
if (namedTypeSymbol.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
{
ITypeSymbol argumentSymbol = namedTypeSymbol.TypeArguments[0];
if (argumentSymbol != typeSymbol)
{
ModifyExpressionRefactoring.ComputeRefactoring(
context,
yieldStatement.Expression,
argumentSymbol,
semanticModel);
}
}
}
}
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CreateConditionFromBooleanExpression))
{
await CreateConditionFromBooleanExpressionRefactoring.ComputeRefactoringAsync(context, yieldStatement.Expression).ConfigureAwait(false);
}
}
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
base.VisitYieldStatement(node);
isSpecial = true;
}
public static bool IsYieldBreak(this YieldStatementSyntax yieldStatement)
{
return(yieldStatement?.ReturnOrBreakKeyword.IsKind(SyntaxKind.BreakKeyword) == true);
}
internal override TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
diagnostics.Add(ErrorCode.ERR_IteratorInInteractive, node.Location);
return(CreateErrorType());
}
public static async Task <Document> RefactorAsync(
Document document,
ReturnStatementSyntax returnStatement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SyntaxToken returnKeyword = returnStatement.ReturnKeyword;
ExpressionSyntax expression = returnStatement.Expression;
switch (GetReplacementKind(returnStatement, null, semanticModel, cancellationToken))
{
case SyntaxKind.YieldReturnStatement:
{
YieldStatementSyntax yieldReturnStatement = YieldStatement(
SyntaxKind.YieldReturnStatement,
Token(returnKeyword.LeadingTrivia, SyntaxKind.YieldKeyword, TriviaList(Space)),
returnKeyword.WithoutLeadingTrivia(),
expression,
returnStatement.SemicolonToken);
return(await document.ReplaceNodeAsync(returnStatement, yieldReturnStatement, cancellationToken).ConfigureAwait(false));
}
case SyntaxKind.ForEachStatement:
{
string name = NameGenerator.Default.EnsureUniqueLocalName(
DefaultNames.ForEachVariable,
semanticModel,
returnStatement.SpanStart,
cancellationToken: cancellationToken);
YieldStatementSyntax yieldReturnStatement = YieldStatement(
SyntaxKind.YieldReturnStatement,
Token(default(SyntaxTriviaList), SyntaxKind.YieldKeyword, TriviaList(Space)),
returnKeyword.WithoutLeadingTrivia(),
IdentifierName(name),
returnStatement.SemicolonToken.WithoutTrailingTrivia());
StatementSyntax newNode = ForEachStatement(
VarType(),
name,
expression,
Block(yieldReturnStatement));
if (EmbeddedStatementHelper.IsEmbeddedStatement(returnStatement))
{
newNode = Block(newNode);
}
newNode = newNode.WithTriviaFrom(returnStatement);
return(await document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken).ConfigureAwait(false));
}
default:
{
Debug.Fail("");
return(document);
}
}
}
private IEnumerable<ITypeSymbol> InferTypeInYieldStatement(YieldStatementSyntax yieldStatement, SyntaxToken? previousToken = null)
{
// If we are position based, then we have to be after the return keyword
if (previousToken.HasValue && (previousToken.Value != yieldStatement.ReturnOrBreakKeyword || yieldStatement.ReturnOrBreakKeyword.IsKind(SyntaxKind.BreakKeyword)))
{
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
var memberSymbol = GetDeclaredMemberSymbolFromOriginalSemanticModel(this.semanticModel, yieldStatement.GetAncestorOrThis<MemberDeclarationSyntax>());
var memberType = memberSymbol.TypeSwitch(
(IMethodSymbol method) => method.ReturnType,
(IPropertySymbol property) => property.Type);
if (memberType is INamedTypeSymbol)
{
if (memberType.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T ||
memberType.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerator_T)
{
return SpecializedCollections.SingletonEnumerable(((INamedTypeSymbol)memberType).TypeArguments[0]);
}
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
/// tree by visiting the node.
/// </remarks>
public override void VisitYieldStatement(YieldStatementSyntax node)
{
this.VisitStatement(node);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
if (node.Expression != null)
{
Visit(node.Expression, _enclosing);
}
_sawYield = true;
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
}
private BoundStatement BindYieldReturnStatement(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
TypeSymbol elementType = this.GetIteratorElementType(node, diagnostics);
BoundExpression argument = (node.Expression == null)
? BadExpression(node)
: BindValue(node.Expression, diagnostics, BindValueKind.RValue);
if (!argument.HasAnyErrors)
{
argument = GenerateConversionForAssignment(elementType, argument, diagnostics);
}
// NOTE: it's possible that more than one of these conditions is satisfied and that
// we won't report the syntactically innermost. However, dev11 appears to check
// them in this order, regardless of syntactic nesting (StatementBinder::bindYield).
if (this.Flags.Includes(BinderFlags.InFinallyBlock))
{
Error(diagnostics, ErrorCode.ERR_BadYieldInFinally, node.YieldKeyword);
}
else if (this.Flags.Includes(BinderFlags.InTryBlockOfTryCatch))
{
Error(diagnostics, ErrorCode.ERR_BadYieldInTryOfCatch, node.YieldKeyword);
}
else if (this.Flags.Includes(BinderFlags.InCatchBlock))
{
Error(diagnostics, ErrorCode.ERR_BadYieldInCatch, node.YieldKeyword);
}
return new BoundYieldReturnStatement(node, argument);
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
Emit <YieldBlock, YieldStatementSyntax>(node);
}
/// <summary>
/// Get the element type of this iterator.
/// </summary>
/// <param name="node">Node to report diagnostics, if any, such as "yield statement cannot be used
/// inside a lambda expression"</param>
/// <param name="diagnostics">Where to place any diagnostics</param>
/// <returns>Element type of the current iterator, or an error type.</returns>
internal virtual TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
return Next.GetIteratorElementType(node, diagnostics);
}
/// <summary>
/// Get the element type of this iterator.
/// </summary>
/// <param name="node">Node to report diagnostics, if any, such as "yield statement cannot be used
/// inside a lambda expression"</param>
/// <param name="diagnostics">Where to place any diagnostics</param>
/// <returns>Element type of the current iterator, or an error type.</returns>
internal virtual TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
return(Next.GetIteratorElementType(node, diagnostics));
}
// This should only be called in the context of syntactically incorrect programs. In other
// contexts statements are surrounded by some enclosing method or lambda.
internal override TypeSymbol GetIteratorElementType(YieldStatementSyntax node, DiagnosticBag diagnostics)
{
// There's supposed to be an enclosing method or lambda.
throw ExceptionUtilities.Unreachable;
}
public override void VisitYieldStatement(YieldStatementSyntax node)
{
this.Logic.Add(this.nodeFactory.CreateYield(node));
}
