public override void VisitFinallyClause(FinallyClauseSyntax node)
{
throw new NotSupportedException();
}
public TryStatementSyntax Update(SyntaxToken tryKeyword, BlockSyntax block, SyntaxList <CatchClauseSyntax> catches, FinallyClauseSyntax @finally) => Update(AttributeLists, tryKeyword, block, catches, @finally);
public override void VisitFinallyClause(FinallyClauseSyntax node)
{
// Do not call base to force the walker to stop.
// Another walker will take care of this finally clause.
}
public override void VisitFinallyClause(FinallyClauseSyntax node)
{
// NOTE: We're going to cheat a bit - we know that the block is definitely going
// to get a map entry, so we don't need to worry about the WithAdditionalFlags
// binder being dropped. That is, there's no point in adding the WithAdditionalFlags
// binder to the map ourselves and having VisitBlock unconditionally overwrite it.
Visit(node.Block, enclosing.WithAdditionalFlags(BinderFlags.InFinallyBlock));
Binder finallyBinder;
Debug.Assert(this.map.TryGetValue(node.Block, out finallyBinder) && finallyBinder.Flags.Includes(BinderFlags.InFinallyBlock));
}
private static SyntaxToken GetFirstExcludedToken(StatementSyntax statement)
{
Debug.Assert(statement != null);
switch (statement.Kind)
{
case SyntaxKind.Block:
return(((BlockSyntax)statement).CloseBraceToken);
case SyntaxKind.BreakStatement:
return(((BreakStatementSyntax)statement).SemicolonToken);
case SyntaxKind.ContinueStatement:
return(((ContinueStatementSyntax)statement).SemicolonToken);
case SyntaxKind.LocalDeclarationStatement:
return(((LocalDeclarationStatementSyntax)statement).SemicolonToken);
case SyntaxKind.DoStatement:
return(((DoStatementSyntax)statement).SemicolonToken);
case SyntaxKind.EmptyStatement:
return(((EmptyStatementSyntax)statement).SemicolonToken);
case SyntaxKind.ExpressionStatement:
return(((ExpressionStatementSyntax)statement).SemicolonToken);
case SyntaxKind.ForStatement:
return(GetFirstExcludedToken(((ForStatementSyntax)statement).Statement));
//case SyntaxKind.GotoDefaultStatement:
//case SyntaxKind.GotoCaseStatement:
//case SyntaxKind.GotoStatement:
// return ((GotoStatementSyntax)statement).SemicolonToken;
case SyntaxKind.IfStatement:
IfStatementSyntax ifStmt = (IfStatementSyntax)statement;
ElseClauseSyntax elseOpt = ifStmt.Else;
return(GetFirstExcludedToken(elseOpt == null ? ifStmt.Statement : elseOpt.Statement));
case SyntaxKind.LabeledStatement:
return(GetFirstExcludedToken(((LabeledStatementSyntax)statement).Statement));
case SyntaxKind.ReturnStatement:
return(((ReturnStatementSyntax)statement).SemicolonToken);
case SyntaxKind.SwitchStatement:
return(((SwitchStatementSyntax)statement).CloseBraceToken);
case SyntaxKind.ThrowStatement:
return(((ThrowStatementSyntax)statement).SemicolonToken);
case SyntaxKind.TryStatement:
TryStatementSyntax tryStmt = (TryStatementSyntax)statement;
FinallyClauseSyntax finallyClause = tryStmt.Finally;
if (finallyClause != null)
{
return(finallyClause.Block.CloseBraceToken);
}
CatchClauseSyntax lastCatch = tryStmt.Catches.LastOrDefault();
if (lastCatch != null)
{
return(lastCatch.Block.CloseBraceToken);
}
return(tryStmt.Block.CloseBraceToken);
case SyntaxKind.UsingStatement:
return(GetFirstExcludedToken(((UsingStatementSyntax)statement).Statement));
case SyntaxKind.WhileStatement:
return(GetFirstExcludedToken(((WhileStatementSyntax)statement).Statement));
default:
throw ExceptionUtilities.UnexpectedValue(statement.Kind);
}
}
public override void VisitFinallyClause(FinallyClauseSyntax node)
{
base.VisitFinallyClause(node);
}
public FinallyStatementInterpreter(StatementInterpreterHandler statementInterpreterHandler, FinallyClauseSyntax finallyClauseSyntax)
{
this.statementInterpreterHandler = statementInterpreterHandler;
this.finallyClauseSyntax = finallyClauseSyntax;
}
public override void VisitFinallyClause(FinallyClauseSyntax node)
{
VisitBlock(node.Block);
}
// Finally体
public virtual void VisitFinallyClauseSyntax(FinallyClauseSyntax value)
{
DefaultVisit(value);
}
public override void VisitFinallyClause(FinallyClauseSyntax node)
{
var body = VisitSyntaxNode(node.Block);
_currentNode = new Finally(body);
}
// // Summary: // Called when the visitor visits a FinallyClauseSyntax node. public virtual void VisitFinallyClause(FinallyClauseSyntax node);
public void AnalyzeACatchBlock(CatchClauseSyntax catchblock)
{
CatchBlock catchBlockInfo = new CatchBlock();
var tree = catchblock.SyntaxTree;
var model = TreeAndModelDic[tree];
TypeSyntax exceptionTypeSyntax = null;
INamedTypeSymbol exceptionNamedTypeSymbol = null;
if (catchblock.Declaration != null)
{
exceptionTypeSyntax = catchblock.Declaration.Type;
exceptionNamedTypeSymbol = model.GetTypeInfo(exceptionTypeSyntax).ConvertedType as INamedTypeSymbol;
if (exceptionNamedTypeSymbol != null)
{
catchBlockInfo.ExceptionType = exceptionNamedTypeSymbol.ToString();
//Binding info:
if (exceptionNamedTypeSymbol.BaseType != null)
{
catchBlockInfo.OperationFeatures["Binded"] = 1;
catchBlockInfo.OperationFeatures["RecoveredBinding"] = model.IsSpeculativeSemanticModel ? 1 : 0;
catchBlockInfo.OperationFeatures["Kind"] = ASTUtilities.FindKind(exceptionNamedTypeSymbol, Compilation);
}
else
{
catchBlockInfo.OperationFeatures["Binded"] = 0;
}
}
else
{
catchBlockInfo.ExceptionType = "!NO_NAMED_TYPE!";
}
}
else
{
catchBlockInfo.ExceptionType = "!NO_EXCEPTION_DECLARED!";
}
//Basic info:
catchBlockInfo.MetaInfo["ExceptionType"] = catchBlockInfo.ExceptionType;
//Try info:
var tryBlock = catchblock.Parent as TryStatementSyntax;
catchBlockInfo.MetaInfo["TryBlock"] = tryBlock.ToString();
catchBlockInfo.OperationFeatures["ParentNodeType"] = ASTUtilities.FindParent(tryBlock).RawKind;
catchBlockInfo.MetaInfo["ParentNodeType"] = ASTUtilities.FindParent(tryBlock).Kind().ToString();
//Common Features - try/catch block
var tryNoTriviaCount = ASTUtilities.countLines(tryBlock.Block) - 2;
var tryFileLinePositionSpan = tree.GetLineSpan(tryBlock.Block.Span);
var tryStartLine = tryFileLinePositionSpan.StartLinePosition.Line + 1;
var tryEndLine = tryFileLinePositionSpan.EndLinePosition.Line + 1;
catchBlockInfo.OperationFeatures["TryStartLine"] = tryStartLine;
catchBlockInfo.OperationFeatures["TryEndLine"] = tryEndLine;
catchBlockInfo.MetaInfo["TryLine"] = tryStartLine.ToString();
catchBlockInfo.OperationFeatures["TryLOC"] = tryNoTriviaCount;
var catchNoTriviaCount = ASTUtilities.countLines(catchblock.Block) - 2;
var catchFileLinePositionSpan = tree.GetLineSpan(catchblock.Block.Span);
var catchStartLine = catchFileLinePositionSpan.StartLinePosition.Line + 1;
var catchEndLine = catchFileLinePositionSpan.EndLinePosition.Line + 1;
catchBlockInfo.OperationFeatures["CatchStartLine"] = catchStartLine;
catchBlockInfo.OperationFeatures["CatchEndLine"] = catchEndLine;
catchBlockInfo.OperationFeatures["CatchLOC"] = catchNoTriviaCount;
catchBlockInfo.OperationFeatures["CatchStart"] = catchFileLinePositionSpan.StartLinePosition.Line;
catchBlockInfo.OperationFeatures["CatchLength"] = catchFileLinePositionSpan.EndLinePosition.Line - catchFileLinePositionSpan.StartLinePosition.Line;
catchBlockInfo.MetaInfo["CatchBlock"] = catchblock.ToString();
catchBlockInfo.FilePath = tree.FilePath;
catchBlockInfo.StartLine = catchStartLine;
catchBlockInfo.MetaInfo["FilePath"] = tree.FilePath;
catchBlockInfo.MetaInfo["StartLine"] = catchStartLine.ToString();
//Common Features - parent type
catchBlockInfo.ParentType = ASTUtilities.FindParentType(tryBlock, model);
catchBlockInfo.MetaInfo["ParentType"] = catchBlockInfo.ParentType;
//Common Features - parent method name
SyntaxNode parentNode = ASTUtilities.FindParentMethod(tryBlock);
catchBlockInfo.ParentMethod = ASTUtilities.GetMethodName(parentNode, TreeAndModelDic, Compilation);;
catchBlockInfo.MetaInfo["ParentMethod"] = catchBlockInfo.ParentMethod;
//Common Features
if (parentNode.IsKind(SyntaxKind.MethodDeclaration))
{
parentNode = (parentNode as MethodDeclarationSyntax).Body;
}
if (parentNode.IsKind(SyntaxKind.ConstructorDeclaration))
{
parentNode = (parentNode as ConstructorDeclarationSyntax).Body;
}
var parentMethodNoTriviaCount = ASTUtilities.countLines(parentNode) - 2;
var parentMethodFileLinePositionSpan = tree.GetLineSpan(parentNode.Span);
var parentMethodStartLine = parentMethodFileLinePositionSpan.StartLinePosition.Line + 1;
var parentMethodEndLine = parentMethodFileLinePositionSpan.EndLinePosition.Line + 1;
catchBlockInfo.OperationFeatures["MethodStartLine"] = parentMethodStartLine;
catchBlockInfo.OperationFeatures["MethodEndLine"] = parentMethodStartLine;
catchBlockInfo.OperationFeatures["MethodLOC"] = parentMethodNoTriviaCount;
//Treatment for TryStatement
bool hasTryStatement = catchblock.DescendantNodesAndSelf()
.OfType <TryStatementSyntax>().Any();
SyntaxNode updatedCatchBlock = catchblock;
if (hasTryStatement == true)
{
try
{
// remove try-catch-finally block inside
updatedCatchBlock = tryblockremover.Visit(catchblock);
}
catch (System.ArgumentNullException e)
{
// ignore the ArgumentNullException
}
}
//Treatment for TryStatement
//RecoverFlag - (based on inner try blocks)
var recoverStatement = FindRecoverStatement(catchblock, model);
if (recoverStatement != null)
{
catchBlockInfo.MetaInfo["RecoverFlag"] = recoverStatement.ToString();
catchBlockInfo.OperationFeatures["RecoverFlag"] = 1;
}
/*
* Flagging inner catch
* CatchClause is a child of a TryStatement, which is a child of a Block, which we wanna know the parent.
* If CatchClause it's the parent, then it's an inner catch. Get the line of the parent try of that.
*/
if (IsInnerCatch(catchblock.Parent))
{
catchBlockInfo.OperationFeatures["InnerCatch"] = 1;
catchBlockInfo.OperationFeatures["ParentTryStartLine"] = tree.GetLineSpan((FindParentCatch(catchblock.Parent).Parent as TryStatementSyntax).Block.Span).StartLinePosition.Line + 1;// tree.getLineNumber(node.getParent().getParent().getParent().getParent().getStartPosition() + 1));
}
//Treatment for MethodInvocation
//Collection of data for statements of: logging, abort,
//Logging
var loggingStatement = FindLoggingIn(updatedCatchBlock);
if (loggingStatement != null)
{
catchBlockInfo.MetaInfo["Logged"] = loggingStatement.ToString();
catchBlockInfo.OperationFeatures["Logged"] = 1;
if (CountLoggingIn(updatedCatchBlock) > 1)
{
catchBlockInfo.OperationFeatures["MultiLog"] = 1;
}
}
//Abort
var abortStatement = FindAbortIn(updatedCatchBlock);
if (abortStatement != null)
{
catchBlockInfo.MetaInfo["Abort"] = abortStatement.ToString();
catchBlockInfo.OperationFeatures["Abort"] = 1;
}
//GetCause - C# is inner exception
var getCauseStatement = FindGetCauseIn(updatedCatchBlock);
if (getCauseStatement != null)
{
catchBlockInfo.MetaInfo["GetCause"] = getCauseStatement.ToString();
catchBlockInfo.OperationFeatures["GetCause"] = 1;
}
//Other - Other INVOCATION
var otherStatement = FindOtherIn(updatedCatchBlock);
if (otherStatement != null)
{
catchBlockInfo.MetaInfo["OtherInvocation"] = otherStatement.ToString();
catchBlockInfo.OperationFeatures["OtherInvocation"] = 1;
}
//Treatment for ThrowStatement
//Collection of data for statements of: throw
var throwStatement = FindThrowIn(updatedCatchBlock);
if (throwStatement != null)
{
catchBlockInfo.MetaInfo["Thrown"] = throwStatement.ToString();
catchBlockInfo.OperationFeatures["NumThrown"] = CountThrowIn(updatedCatchBlock);
catchBlockInfo.OperationFeatures["NumThrowNew"] = CountThrowNewIn(updatedCatchBlock);
catchBlockInfo.OperationFeatures["NumThrowWrapCurrentException"] = CountThrowWrapIn(updatedCatchBlock, catchblock.Declaration?.Identifier.ToString());
}
//Treatment for ReturnStatement
var returnStatement = FindReturnIn(updatedCatchBlock);
if (returnStatement != null)
{
catchBlockInfo.MetaInfo["Return"] = returnStatement.ToString();
catchBlockInfo.OperationFeatures["Return"] = 1;
}
//Treatment for ContinueStatement
var continueStatement = FindContinueIn(updatedCatchBlock);
if (continueStatement != null)
{
catchBlockInfo.MetaInfo["Continue"] = continueStatement.ToString();
catchBlockInfo.OperationFeatures["Continue"] = 1;
}
//var setLogicFlag = FindSetLogicFlagIn(updatedCatchBlock);
//if (setLogicFlag != null)
//{
// catchBlockInfo.MetaInfo["SetLogicFlag"] = setLogicFlag.ToString();
// catchBlockInfo.OperationFeatures["SetLogicFlag"] = 1;
//}
//var otherOperation = HasOtherOperation(updatedCatchBlock, model);
//if (otherOperation != null)
//{
// catchBlockInfo.MetaInfo["OtherOperation"] = otherOperation.ToString();
// catchBlockInfo.OperationFeatures["OtherOperation"] = 1;
//}
//EmptyBlock
if (IsEmptyBlock(updatedCatchBlock))
{
catchBlockInfo.OperationFeatures["EmptyBlock"] = 1;
}
//CatchException
if (exceptionNamedTypeSymbol != null)
{
if (exceptionNamedTypeSymbol.Equals(Compilation.GetTypeByMetadataName("System.Exception")))
{
catchBlockInfo.OperationFeatures["CatchException"] = 1;
}
else
{
catchBlockInfo.OperationFeatures["CatchException"] = 0;
}
}
//ToDo
if (IsToDo(updatedCatchBlock))
{
catchBlockInfo.OperationFeatures["ToDo"] = 1;
}
//var variableAndComments = GetVariablesAndComments(tryBlock.Block);
//var containingMethod = GetContainingMethodName(tryBlock, model);
//var methodNameList = GetAllInvokedMethodNamesByBFS(tryBlock.Block, treeAndModelDic, compilation);
var tryPossibleExceptionsCustomVisitor = new PossibleExceptionsCustomVisitor(Compilation, TreeAndModelDic, 0, true, tree.FilePath, catchStartLine, exceptionNamedTypeSymbol);
tryPossibleExceptionsCustomVisitor.Visit(tryBlock.Block);
/*
* Process for possible exceptions
*/
getExceptionFlows(this.PossibleExceptionsList, tryPossibleExceptionsCustomVisitor.getClosedExceptionFlows(), Compilation);
//catchBlockInfo.MetaInfo["TryMethods"] = possibleExceptionsCustomVisitor.PrintInvokedMethodsHandlerType();
catchBlockInfo.MetaInfo["TryMethodsAndExceptions"] = tryPossibleExceptionsCustomVisitor.PrintInvokedMethodsPossibleExceptions();
catchBlockInfo.OperationFeatures["NumDistinctMethods"] = tryPossibleExceptionsCustomVisitor.countInvokedMethodsHandlerType();
catchBlockInfo.MetaInfo["TryMethodsBinded"] = tryPossibleExceptionsCustomVisitor.PrintInvokedMethodsBinded();
catchBlockInfo.OperationFeatures["NumDistinctMethodsNotBinded"] = tryPossibleExceptionsCustomVisitor.getNumMethodsNotBinded();
catchBlockInfo.MetaInfo["DistinctExceptions"] = tryPossibleExceptionsCustomVisitor.PrintDistinctPossibleExceptions();
catchBlockInfo.OperationFeatures["NumDistinctExceptions"] = tryPossibleExceptionsCustomVisitor.getDistinctPossibleExceptions().Count;
catchBlockInfo.OperationFeatures["NumSpecificHandler"] = tryPossibleExceptionsCustomVisitor.getNumSpecificHandler();
catchBlockInfo.OperationFeatures["NumSubsumptionHandler"] = tryPossibleExceptionsCustomVisitor.getNumSubsumptionHandler();
catchBlockInfo.OperationFeatures["NumSupersumptionHandler"] = tryPossibleExceptionsCustomVisitor.getNumSupersumptionHandler();
catchBlockInfo.OperationFeatures["NumOtherHandler"] = tryPossibleExceptionsCustomVisitor.getNumOtherHandler();
catchBlockInfo.OperationFeatures["MaxLevel"] = tryPossibleExceptionsCustomVisitor.getChildrenMaxLevel();
catchBlockInfo.OperationFeatures["NumIsDocSemantic"] = tryPossibleExceptionsCustomVisitor.getNumIsDocSemantic();
catchBlockInfo.OperationFeatures["NumIsDocSyntax"] = tryPossibleExceptionsCustomVisitor.getNumIsDocSyntax();
catchBlockInfo.OperationFeatures["NumIsThrow"] = tryPossibleExceptionsCustomVisitor.getNumIsThrow();
//FinallyThrowing
FinallyClauseSyntax finallyBlock = tryBlock.Finally;
if (finallyBlock != null)
{
catchBlockInfo.MetaInfo["FinallyBlock"] = finallyBlock.ToString();
var finallyPossibleExceptionsCustomVisitor = new PossibleExceptionsCustomVisitor(Compilation, TreeAndModelDic, 0, true, tree.FilePath, catchStartLine, exceptionNamedTypeSymbol);
finallyPossibleExceptionsCustomVisitor.Visit(finallyBlock.Block);
if (finallyBlock.DescendantNodes().OfType <ThrowStatementSyntax>().Any() ||
finallyPossibleExceptionsCustomVisitor.getDistinctPossibleExceptions().Count > 0)
{
catchBlockInfo.OperationFeatures["FinallyThrowing"] = 1;
}
}
//var methodAndExceptionList = GetAllInvokedMethodNamesAndExceptionsByBFS(tryBlock.Block, treeAndModelDic, compilation);
//catchBlockInfo.OperationFeatures["NumMethod"] = methodAndExceptionList[0].Count;
//catchBlockInfo.OperationFeatures["NumExceptions"] = methodAndExceptionList[1].Count;
//catchBlockInfo.TextFeatures = methodAndExceptionList[0];
//if (containingMethod != null)
//{
// MergeDic<string>(ref catchBlockInfo.TextFeatures,
// new Dictionary<string, int>() { { containingMethod, 1 } });
//}
//MergeDic<string>(ref catchBlockInfo.TextFeatures,
// new Dictionary<string, int>() { { "##spliter##", 0 } }); // to seperate methods and variables
//MergeDic<string>(ref catchBlockInfo.TextFeatures, variableAndComments);
Catches.Add(catchBlockInfo);
}
public override void VisitFinallyClause(FinallyClauseSyntax node)
{
LogicalLineCount++;
base.VisitFinallyClause(node);
}
public static TryStatementSyntax TryStatement(BlockSyntax block, CatchClauseSyntax @catch, FinallyClauseSyntax @finally = null)
{
return(SyntaxFactory.TryStatement(block, SingletonList(@catch), @finally));
}
public static TryStatementSyntax TryStatement(BlockSyntax block, SyntaxList <CatchClauseSyntax> catches, FinallyClauseSyntax @finally) => TryStatement(attributeLists: default, block, catches, @finally);
public void VisitFinallyClause(FinallyClauseSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
if (_writer.Configuration.LineBreaksAndWrapping.PlaceOnNewLine.PlaceFinallyOnNewLine)
_writer.WriteIndent();
else
_writer.WriteSpace();
_writer.WriteKeyword(PrinterKeyword.Finally);
node.Block.Accept(this);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitFinallyClause(FinallyClauseSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitFinallyClause(node);
}
public override Evaluation VisitFinallyClause(FinallyClauseSyntax node)
{
node.Block?.Accept <Evaluation>(this);
return(base.VisitFinallyClause(node));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitFinallyClause(FinallyClauseSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitFinallyClause(node);
}
public override Ust VisitFinallyClause(FinallyClauseSyntax node)
{
var result = (BlockStatement)VisitBlock(node.Block);
return(result);
}
public virtual void VisitFinally(FinallyClauseSyntax node) => DefaultVisit(node);
internal static SyntaxToken GetFirstExcludedToken(StatementSyntax statement)
{
Debug.Assert(statement != null);
switch (statement.Kind())
{
case SyntaxKind.Block:
return(((BlockSyntax)statement).CloseBraceToken);
case SyntaxKind.BreakStatement:
return(((BreakStatementSyntax)statement).SemicolonToken);
case SyntaxKind.CheckedStatement:
case SyntaxKind.UncheckedStatement:
return(((CheckedStatementSyntax)statement).Block.CloseBraceToken);
case SyntaxKind.ContinueStatement:
return(((ContinueStatementSyntax)statement).SemicolonToken);
case SyntaxKind.LocalDeclarationStatement:
return(((LocalDeclarationStatementSyntax)statement).SemicolonToken);
case SyntaxKind.DoStatement:
return(((DoStatementSyntax)statement).SemicolonToken);
case SyntaxKind.EmptyStatement:
return(((EmptyStatementSyntax)statement).SemicolonToken);
case SyntaxKind.ExpressionStatement:
return(((ExpressionStatementSyntax)statement).SemicolonToken);
case SyntaxKind.FixedStatement:
return(GetFirstExcludedToken(((FixedStatementSyntax)statement).Statement));
case SyntaxKind.ForEachStatement:
case SyntaxKind.ForEachVariableStatement:
return(GetFirstExcludedToken(((CommonForEachStatementSyntax)statement).Statement));
case SyntaxKind.ForStatement:
return(GetFirstExcludedToken(((ForStatementSyntax)statement).Statement));
case SyntaxKind.GotoDefaultStatement:
case SyntaxKind.GotoCaseStatement:
case SyntaxKind.GotoStatement:
return(((GotoStatementSyntax)statement).SemicolonToken);
case SyntaxKind.IfStatement:
IfStatementSyntax ifStmt = (IfStatementSyntax)statement;
ElseClauseSyntax elseOpt = ifStmt.Else;
return(GetFirstExcludedToken(elseOpt == null ? ifStmt.Statement : elseOpt.Statement));
case SyntaxKind.LabeledStatement:
return(GetFirstExcludedToken(((LabeledStatementSyntax)statement).Statement));
case SyntaxKind.LockStatement:
return(GetFirstExcludedToken(((LockStatementSyntax)statement).Statement));
case SyntaxKind.ReturnStatement:
return(((ReturnStatementSyntax)statement).SemicolonToken);
case SyntaxKind.SwitchStatement:
return(((SwitchStatementSyntax)statement).CloseBraceToken);
case SyntaxKind.ThrowStatement:
return(((ThrowStatementSyntax)statement).SemicolonToken);
case SyntaxKind.TryStatement:
TryStatementSyntax tryStmt = (TryStatementSyntax)statement;
FinallyClauseSyntax finallyClause = tryStmt.Finally;
if (finallyClause != null)
{
return(finallyClause.Block.CloseBraceToken);
}
CatchClauseSyntax lastCatch = tryStmt.Catches.LastOrDefault();
if (lastCatch != null)
{
return(lastCatch.Block.CloseBraceToken);
}
return(tryStmt.Block.CloseBraceToken);
case SyntaxKind.UnsafeStatement:
return(((UnsafeStatementSyntax)statement).Block.CloseBraceToken);
case SyntaxKind.UsingStatement:
return(GetFirstExcludedToken(((UsingStatementSyntax)statement).Statement));
case SyntaxKind.WhileStatement:
return(GetFirstExcludedToken(((WhileStatementSyntax)statement).Statement));
case SyntaxKind.YieldReturnStatement:
case SyntaxKind.YieldBreakStatement:
return(((YieldStatementSyntax)statement).SemicolonToken);
case SyntaxKind.LocalFunctionStatement:
LocalFunctionStatementSyntax localFunctionStmt = (LocalFunctionStatementSyntax)statement;
if (localFunctionStmt.Body != null)
{
return(GetFirstExcludedToken(localFunctionStmt.Body));
}
if (localFunctionStmt.SemicolonToken != default(SyntaxToken))
{
return(localFunctionStmt.SemicolonToken);
}
return(localFunctionStmt.ParameterList.GetLastToken());
default:
throw ExceptionUtilities.UnexpectedValue(statement.Kind());
}
}
public TameFinallyClauseSyntax(FinallyClauseSyntax node)
{
Node = node;
AddChildren();
}
public FinallyClauseTranslation(FinallyClauseSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Block = syntax.Block.Get<BlockTranslation>(this);
}
public FinallyClauseTranslation(FinallyClauseSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Block = syntax.Block.Get <BlockTranslation>(this);
}
public override void VisitFinallyClause(FinallyClauseSyntax node)
{
// NOTE: We're going to cheat a bit - we know that the block is definitely going
// to get a map entry, so we don't need to worry about the WithAdditionalFlags
// binder being dropped. That is, there's no point in adding the WithAdditionalFlags
// binder to the map ourselves and having VisitBlock unconditionally overwrite it.
// If this finally block is nested inside a catch block, we need to use a distinct
// binder flag so that we can detect the nesting order for error CS074: A throw
// statement with no arguments is not allowed in a finally clause that is nested inside
// the nearest enclosing catch clause.
var additionalFlags = BinderFlags.InFinallyBlock;
if (_enclosing.Flags.Includes(BinderFlags.InCatchBlock))
{
additionalFlags |= BinderFlags.InNestedFinallyBlock;
}
Visit(node.Block, _enclosing.WithAdditionalFlags(additionalFlags));
Binder finallyBinder;
Debug.Assert(_map.TryGetValue(node.Block, out finallyBinder) && finallyBinder.Flags.Includes(BinderFlags.InFinallyBlock));
}
public static SyntaxNode TryCatchFinallySafe(this SyntaxNode subjectStatement, Dictionary <string, TypeSyntax> exceptionArgumentsInfo,
Func <IdentifierNameSyntax, SyntaxList <StatementSyntax> > generateCatchStatement, SyntaxNode root, SemanticModel model, FinallyClauseSyntax finallyClauseSyntax,
CancellationToken cancellationToken = default(CancellationToken))
{
var containingMethod = subjectStatement.GetContainingMemberDeclaration();
var tryTextSpan = containingMethod.GetSpanOfAssignmentDependenciesInSpan(
subjectStatement.FullSpan, model, cancellationToken);
var tryBlockStatements = containingMethod.SyntaxTree
.GetRoot(cancellationToken).DescendantNodes()
.Where(x => tryTextSpan.Contains(x.Span))
.OfType <StatementSyntax>().ToArray();
var catchClauses = exceptionArgumentsInfo.Select(i =>
{
var exceptionArgumentIdentifierName = SyntaxFactory.IdentifierName(i.Key);
return(SyntaxFactory.CatchClause()
.WithDeclaration(
SyntaxFactory.CatchDeclaration(i.Value)
.WithIdentifier(exceptionArgumentIdentifierName.Identifier))
.WithBlock(SyntaxFactory.Block(generateCatchStatement(exceptionArgumentIdentifierName))
));
});
var tryStatement = SyntaxFactory.TryStatement(
SyntaxFactory.Block(SyntaxFactory.List(tryBlockStatements)),
SyntaxFactory.List(catchClauses),
finallyClauseSyntax)
.WithAdditionalAnnotations(Formatter.Annotation);
var newMethod = containingMethod.ReplaceNodes(tryBlockStatements.ToImmutableList(), tryStatement);
var compilationUnitSyntax = (CompilationUnitSyntax)root.ReplaceNode(containingMethod, newMethod);
var usings = compilationUnitSyntax.Usings;
if (!usings.Any(e => e.Name.ToString().Equals(typeof(Task).Namespace)))
{
var usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(typeof(Task).Namespace));
compilationUnitSyntax = compilationUnitSyntax.AddUsings(usingDirective);
}
if (!usings.Any(e => e.Name.ToString().Equals(typeof(Debug).Namespace)))
{
var usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(typeof(Debug).Namespace));
compilationUnitSyntax = compilationUnitSyntax.AddUsings(usingDirective);
}
return(compilationUnitSyntax);
}
