public override void VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
DestructorWalker walker = this.CreateSyntaxWalker<DestructorWalker>(node);
walker.Visit(node);
this.Destructors.Add(walker);
base.VisitDestructorDeclaration(node);
}
public override SyntaxNode VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
if (node == null)
return null;
var symbol = _semanticModel.GetDeclaredSymbol(node);
node = (DestructorDeclarationSyntax)base.VisitDestructorDeclaration(node);
if (!IsPrivateOrInternal(symbol.DeclaredAccessibility))
node = (DestructorDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId());
return node;
}
public static void WriteDestructor(OutputWriter writer, DestructorDeclarationSyntax destructor)
{
if (destructor.Body == null)
return;
writer.WriteLine("~this()");
writer.OpenBrace();
if (destructor.Body != null)
{
foreach (var statement in destructor.Body.As<BlockSyntax>().Statements)
Core.Write(writer, statement);
}
writer.CloseBrace();
}
internal SourceDestructorSymbol(
SourceMemberContainerTypeSymbol containingType,
DestructorDeclarationSyntax syntax,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), syntax.Body?.GetReference() ?? syntax.ExpressionBody?.GetReference() , syntax.Identifier.GetLocation())
{
const MethodKind methodKind = MethodKind.Destructor;
Location location = this.Locations[0];
bool modifierErrors;
var declarationModifiers = MakeModifiers(syntax.Modifiers, location, diagnostics, out modifierErrors);
this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExtensionMethod: false);
bool hasBlockBody = syntax.Body != null;
_isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
if (hasBlockBody || _isExpressionBodied)
{
if (IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
}
if (!modifierErrors && bodySyntaxReferenceOpt == null && !IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ConcreteMissingBody, location, this);
}
Debug.Assert(syntax.ParameterList.Parameters.Count == 0);
if (containingType.IsStatic)
{
diagnostics.Add(ErrorCode.ERR_DestructorInStaticClass, location, this);
}
else if (!containingType.IsReferenceType)
{
diagnostics.Add(ErrorCode.ERR_OnlyClassesCanContainDestructors, location, this);
}
}
private static void AppendMethodIdentifier(DestructorDeclarationSyntax syntax, StringBuilder builder)
{
builder.Append(syntax.Identifier.ValueText);
}
private static string GetDestructorSignatureString(DestructorDeclarationSyntax syntax)
{
var builder = new StringBuilder();
AppendMethodIdentifier(syntax, builder);
return builder.ToString();
}
public override SyntaxNode VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.DestructorNotSupport);
return node;
}
public void AddFunction(DestructorDeclarationSyntax node, SemanticModel Model)
{
IMethodSymbol ms = Model.GetDeclaredSymbol(node);
AddFunction(ms, Model);
}
public override void VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
_members.Add(node);
}
public override void VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
base.VisitDestructorDeclaration(node);
Chunk.AddFunction(node, Model);
}
public override void VisitDestructorDeclaration (DestructorDeclarationSyntax node)
{
base.VisitDestructorDeclaration (node);
Append (node);
}
public static string DestructorDeclaration(DestructorDeclarationSyntax destructor)
{
var parsedAttributes = ParseAttributes(destructor.AttributeLists);
var output = parsedAttributes.Item1;
return output + "deinit " + Block(destructor.Body);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitDestructorDeclaration(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitDestructorDeclaration(node);
}
public override void VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
VisitBlock(node.Body);
}
public override void VisitDestructorDeclaration(DestructorDeclarationSyntax node)
{
CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node));
}
private void ClassifyUpdate(DestructorDeclarationSyntax oldNode, DestructorDeclarationSyntax newNode)
{
ClassifyMethodBodyRudeUpdate(
oldNode.Body,
newNode.Body,
containingMethodOpt: null,
containingType: (TypeDeclarationSyntax)newNode.Parent);
}
private Destructor TransverseDestructors(DestructorDeclarationSyntax dds)
{
Destructor retDestructor = new Destructor();
//public int DecisionsCount { get; }
//public int ExitPoints { get; set; }
//public bool IsFriend { get; }
//public bool IsPolymophic { get; }
//public bool IsPublic { get; }
//public bool IsStatic { get; }
//public List<Preprocessor> Preprocessors { get; set; }
retDestructor.Name = dds.Identifier.ValueText;
if (dds.HasLeadingTrivia)
{
SetOuterComments(retDestructor, dds.GetLeadingTrivia().ToFullString());
}
if (dds.HasTrailingTrivia)
{
SetInnerComments(retDestructor, dds.GetTrailingTrivia().ToFullString());
}
foreach (SyntaxToken st in dds.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
retDestructor.Encapsulation.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
retDestructor.Qualifiers.Add(qual);
}
}
//TypeSyntax ts = cds.ReturnType;
//Model.Type retType = new Model.Type();
//retType.Name = ts.ToString();
//retType.IsKnownType = ts.Kind.IsKeywordKind();
//retType.IsNotUserDefined = ts.Kind.IsKeywordKind();
//TODO
//rettype.generictype
//retDestructor.ReturnType = retType;
ParameterListSyntax pls = dds.ParameterList;
foreach (ParameterSyntax ps in pls.Parameters)
{
retDestructor.Parameters.Add(TraverseParamaters(ps));
}
BlockSyntax bs = dds.Body;
var labelStatements = from aLabelStatement in bs.ChildNodes().OfType<LabeledStatementSyntax>() select aLabelStatement;
foreach (LabeledStatementSyntax lss in labelStatements)
{
retDestructor.LabelStatements.Add(TraverseLabelStatements(lss));
}
var goToStatements = from aGoToStatement in bs.ChildNodes().OfType<GotoStatementSyntax>() select aGoToStatement;
foreach (GotoStatementSyntax gtss in goToStatements)
{
GoTo gt = TraverseGoToStatements(gtss);
retDestructor.GoToStatements.Add(gt);
}
//Preprocessors = new List<Preprocessor>();
//Base = new List<InvokedMethod>();
//Decisions = new Decisions();
var accessVarsDecl = from aAccessVarsDecl in bs.ChildNodes().OfType<LocalDeclarationStatementSyntax>() select aAccessVarsDecl;
foreach (LocalDeclarationStatementSyntax ldss in accessVarsDecl)
{
Method tempMethod = TransverseAccessVars(ldss);
retDestructor.AccessedVariables.AddRange(tempMethod.AccessedVariables);
retDestructor.InvokedMethods.AddRange(tempMethod.InvokedMethods);
}
var ifStatements = from aIfStatement in bs.ChildNodes().OfType<IfStatementSyntax>() select aIfStatement;
foreach (IfStatementSyntax iss in ifStatements)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseIfStatements(iss, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var elseStatements = from aElseStatements in bs.ChildNodes().OfType<ElseClauseSyntax>() select aElseStatements;
foreach (ElseClauseSyntax ecs in elseStatements)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseElseClauses(ecs, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var whileLoops = from aWhileLoop in bs.ChildNodes().OfType<WhileStatementSyntax>() select aWhileLoop;
foreach (WhileStatementSyntax wss in whileLoops)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseWhileLoops(wss, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var doWhileLoops = from aDoWhileLoop in bs.ChildNodes().OfType<DoStatementSyntax>() select aDoWhileLoop;
foreach (DoStatementSyntax dss in doWhileLoops)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseDoStatements(dss, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var forLoops = from aForLoop in bs.ChildNodes().OfType<ForStatementSyntax>() select aForLoop;
foreach (ForStatementSyntax fss in forLoops)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseForStatements(fss, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var foreachLoops = from aForeachLoop in bs.ChildNodes().OfType<ForEachStatementSyntax>() select aForeachLoop;
foreach (ForEachStatementSyntax fess in foreachLoops)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseForEachStatements(fess, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var switches = from aSwitch in bs.ChildNodes().OfType<SwitchStatementSyntax>() select aSwitch;
foreach (SwitchStatementSyntax sss in switches)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseSwitchStatements(sss, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var catches = from aCatch in bs.ChildNodes().OfType<CatchClauseSyntax>() select aCatch;
foreach (CatchClauseSyntax ccs in catches)
{
int exitPoints = retDestructor.ExitPoints;
Decisions tempDecision = TraverseCatchClauses(ccs, ref exitPoints);
retDestructor.Decisions.IfStatements.AddRange(tempDecision.IfStatements);
retDestructor.Decisions.ElseStatements.AddRange(tempDecision.ElseStatements);
retDestructor.Decisions.ForEachStatements.AddRange(tempDecision.ForEachStatements);
retDestructor.Decisions.ForStatements.AddRange(tempDecision.ForStatements);
retDestructor.Decisions.WhileLoops.AddRange(tempDecision.WhileLoops);
retDestructor.Decisions.DoWhileLoops.AddRange(tempDecision.DoWhileLoops);
retDestructor.Decisions.Catches.AddRange(tempDecision.Catches);
retDestructor.Decisions.SwitchStatements.AddRange(tempDecision.SwitchStatements);
retDestructor.ExitPoints = exitPoints;
}
var breaks = from aBreak in bs.ChildNodes().OfType<BreakStatementSyntax>() select aBreak;
foreach (BreakStatementSyntax bss in breaks)
{
//TODO get breaks
//note that breaks are NOT in retMethod.Decisions
}
var checks = from aCheck in bs.ChildNodes().OfType<CheckedStatementSyntax>() select aCheck;
foreach (CheckedStatementSyntax css in checks)
{
//TODO get checks
//note that checks are NOT in retMethod.Decisions
}
var continues = from aContinue in bs.ChildNodes().OfType<ContinueStatementSyntax>() select aContinue;
foreach (ContinueStatementSyntax css in continues)
{
//TODO get continues
//note that continues are NOT in retMethod.Decisions
}
var emptys = from aEmpty in bs.ChildNodes().OfType<EmptyStatementSyntax>() select aEmpty;
foreach (EmptyStatementSyntax ess in emptys)
{
//TODO get emptys
//note that emptys are NOT in retMethod.Decisions
}
var exprs = from aExpr in bs.ChildNodes().OfType<ExpressionStatementSyntax>() select aExpr;
foreach (ExpressionStatementSyntax ess in exprs)
{
//TODO get expressions
//note that expressions are NOT in retMethod.Decisions
}
var fixeds = from aFixed in bs.ChildNodes().OfType<FixedStatementSyntax>() select aFixed;
foreach (FixedStatementSyntax fss in fixeds)
{
//TODO get fixed
//note that these are NOT in retMethod.Decisions
}
var locks = from aLock in bs.ChildNodes().OfType<LockStatementSyntax>() select aLock;
foreach (LockStatementSyntax lss in locks)
{
//TODO get lock
//note that these are NOT in retMethod.Decisions
}
var returns = from aReturn in bs.ChildNodes().OfType<ReturnStatementSyntax>() select aReturn;
foreach (ReturnStatementSyntax rss in returns)
{
//TODO get returns
//note that these are NOT in retMethod.Decisions
}
var throws = from aThrow in bs.ChildNodes().OfType<ThrowStatementSyntax>() select aThrow;
foreach (ThrowStatementSyntax tss in throws)
{
//TODO get throws
//note that these are NOT in retMethod.Decisions
}
var trys = from aTry in bs.ChildNodes().OfType<TryStatementSyntax>() select aTry;
foreach (TryStatementSyntax tss in trys)
{
//TODO get trys
//note that these are NOT in retMethod.Decisions
}
var unsafes = from aUnsafe in bs.ChildNodes().OfType<UnsafeStatementSyntax>() select aUnsafe;
foreach (UnsafeStatementSyntax uss in unsafes)
{
//TODO get unsafes
//note that these are NOT in retMethod.Decisions
}
var usings = from aUsing in bs.ChildNodes().OfType<UsingStatementSyntax>() select aUsing;
foreach (UsingStatementSyntax uss in usings)
{
//TODO get usings
//note that these are NOT in retMethod.Decisions
}
var yields = from aYield in bs.ChildNodes().OfType<YieldStatementSyntax>() select aYield;
foreach (YieldStatementSyntax yss in yields)
{
//TODO get yields
//note that these are NOT in retMethod.Decisions
}
var invokedMethods = from aInvokedMethod in bs.ChildNodes().OfType<InvocationExpressionSyntax>() select aInvokedMethod;
foreach (InvocationExpressionSyntax ies in invokedMethods)
{
Method tempMethod = TraverseInvocationExpression(ies);
retDestructor.InvokedMethods.AddRange(tempMethod.InvokedMethods);
retDestructor.AccessedVariables.AddRange(tempMethod.AccessedVariables);
}
//InvokedMethods = new List<InvokedMethod>();
return retDestructor;
}
