public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
StructWalker walker = this.CreateSyntaxWalker<StructWalker>(node);
walker.Visit(node);
this.Structs.Add(walker);
base.VisitStructDeclaration(node);
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
if (compilation != null)
{
var type = compilation.GetSemanticModel(node.SyntaxTree).GetDeclaredSymbol(node);
types.Add(type);
}
typeDeclarations.Add(node);
base.VisitStructDeclaration(node);
}
//public StructDeclarationTranslation() { }
public StructDeclarationTranslation(StructDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
if(BaseList == null)
{
BaseList = new BaseListTranslation();
BaseList.Parent = this;
BaseList.Types = new SeparatedSyntaxListTranslation<BaseTypeSyntax, BaseTypeTranslation>();
BaseList.Types.Parent = BaseList;
}
//BaseList.Types.Add(new BaseTypeTranslation() { SyntaxString = TC.IStruct });
}
/// <summary>
/// Normalizes the <paramref name="structDeclaration" />.
/// </summary>
public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax structDeclaration)
{
structDeclaration = (StructDeclarationSyntax)base.VisitStructDeclaration(structDeclaration);
if (structDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword))
return structDeclaration;
var partialKeyword = SyntaxFactory.Token(SyntaxKind.PartialKeyword).WithTrailingSpace();
partialKeyword = partialKeyword.WithLeadingTrivia(structDeclaration.Keyword.LeadingTrivia);
structDeclaration = structDeclaration.WithModifiers(structDeclaration.Modifiers.Add(partialKeyword));
return structDeclaration.WithKeyword(structDeclaration.Keyword.WithLeadingSpace());
}
/// <summary>
/// Normalizes the <paramref name="structDeclaration" />.
/// </summary>
public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax structDeclaration)
{
structDeclaration = (StructDeclarationSyntax)base.VisitStructDeclaration(structDeclaration);
if (!structDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword))
{
var partialKeyword = SyntaxFactory.Token(SyntaxKind.PartialKeyword).WithTrailingSpace();
structDeclaration = structDeclaration.WithModifiers(structDeclaration.Modifiers.Add(partialKeyword));
}
return structDeclaration;
}
private static StructNode GetStructNode(StructDeclarationSyntax EachStruct)
{
StructNode structnode = new StructNode();
structnode.Name = EachStruct.Identifier.ToString();
// For each member in that class
foreach (var member in EachStruct.Members)
{
if (member is FieldDeclarationSyntax)
{
FieldDeclarationSyntax fd = member as FieldDeclarationSyntax;
foreach (var field in GetFieldNodes(fd))
{
structnode.Fields.Add(field);
}
}
else if (member is MethodDeclarationSyntax)
{
MethodDeclarationSyntax method = member as MethodDeclarationSyntax;
structnode.Methods.Add(GetMethodNode(method));
}
else if (member is PropertyDeclarationSyntax)
{
PropertyDeclarationSyntax property = member as PropertyDeclarationSyntax;
structnode.Properties.Add(GetPropertyNode(property));
}
else if (member is EventFieldDeclarationSyntax)
{
EventFieldDeclarationSyntax evnt = member as EventFieldDeclarationSyntax;
structnode.Events.Add(GetEventNode(evnt));
}
}
if (EachStruct.BaseList != null)
{
foreach (var baseType in EachStruct.BaseList.Types)
{
structnode.Links.Add(baseType.ToString());
}
}
return structnode;
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
base.VisitStructDeclaration(node);
_types.Add(node);
}
private static SyntaxNode HandleStructDeclaration(StructDeclarationSyntax node)
{
SyntaxToken triviaToken = node.Keyword;
if (triviaToken.IsMissing)
{
return null;
}
SyntaxKind defaultVisibility = IsNestedType(node) ? SyntaxKind.PrivateKeyword : SyntaxKind.InternalKeyword;
SyntaxTokenList modifiers = DeclarationModifiersHelper.AddModifier(node.Modifiers, ref triviaToken, defaultVisibility);
return node
.WithKeyword(triviaToken)
.WithModifiers(modifiers)
.WithoutFormatting();
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node));
base.VisitStructDeclaration(node);
}
public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax node)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.StructNotSupport);
return node;
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
AsParent(node, node.Identifier.Text, () => base.VisitStructDeclaration(node), node.Identifier.GetLocation());
}
/// <summary>
/// Returns the full name of the given struct.
/// </summary>
/// <param name="node">SyntaxNode</param>
/// <returns>string</returns>
public string GetFullStructName(StructDeclarationSyntax node)
{
string name = node.Identifier.ValueText;
return this.GetFullQualifierNameOfSyntaxNode(node) + name;
}
public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax node)
{
node = (StructDeclarationSyntax)base.VisitStructDeclaration(node);
var typeDeclKindKeyword = node.Keyword;
if (transformKind == TransformKind.StructDeclToClassDecl)
{
var classToken = SyntaxFactory.Token(typeDeclKindKeyword.LeadingTrivia, SyntaxKind.ClassKeyword, typeDeclKindKeyword.TrailingTrivia);
return SyntaxFactory.ClassDeclaration(node.AttributeLists, node.Modifiers, classToken, node.Identifier,
node.TypeParameterList, node.BaseList, node.ConstraintClauses, node.OpenBraceToken, node.Members, node.CloseBraceToken,
node.SemicolonToken);
}
return node;
}
public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax structnode)
{
return VisitTypeDeclaration(structnode);
//#region CodeContracts
//Contract.Ensures(invariantmethod != null);
//Contract.Assume(structnode != null);
//#endregion CodeContracts
//var newmems = structnode.Members;
//var text = String.Format("\n[ContractInvariantMethod]\nprivate void {0}ObjectInvariantMethod() {{}}\n", classnode.Identifier.ToString());
//var comp = SyntaxFactory.ParseCompilationUnit(text);
//var objinv = comp.Members[0];
//newmems = newmems.Add(objinv);
//var newclass = structnode.WithMembers(newmems);
//invariantmethod = (MethodDeclarationSyntax) newclass.Members.Last();
//return newclass; // do not descend into class
}
private void ProcStructDeclarationSyntax(StructDeclarationSyntax syntax, int indentCount)
{
writeIndents(indentCount);
writer.Write("interface ");
writer.Write(syntax.Identifier);
writer.Write(" {\n");
if (syntax.BaseList != null && syntax.BaseList.Types.Count > 0)
{
throw new Exception("Not supported");
}
foreach (var m in syntax.Members)
{
procMemberDeclarationSyntax(m, indentCount + 1);
}
writeIndents(indentCount);
writer.Write("}\n");
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitStructDeclaration(StructDeclarationSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitStructDeclaration(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitStructDeclaration(StructDeclarationSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitStructDeclaration(node);
}
public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax node)
{
return VisitMemberDeclaration(node, base.VisitStructDeclaration(node));
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
if (SkipInnerTypeDeclaration(node)) { return; }
_inheritanceRelationsips.AddFrom(node);
var typeName = TypeNameText.From(node);
var name = typeName.Identifier;
var typeParam = typeName.TypeArguments;
WriteLine($"class {name}{typeParam} <<struct>> {{");
nestingDepth++;
base.VisitStructDeclaration(node);
nestingDepth--;
WriteLine("}");
}
public override void VisitStructDeclaration (StructDeclarationSyntax node)
{
VisitBody (node);
}
/// <summary>
/// Traverse AST node that represents struct declaration
/// </summary>
/// <param name="node">AST node.</param>
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
try
{
if (!node.Identifier.Span.IsEmpty)
{
var symbol = _sm.GetDeclaredSymbol(node);
// Structs can also be partial
if (!_defined.Contains(symbol))
{
_defined.Add(symbol);
var def = Def.For(symbol: symbol, type: "struct", name: symbol.Name).At(_path, node.Identifier.Span);
if (symbol.IsExported())
{
def.Exported = true;
}
AddDef(def, DocProcessor.ForClass(symbol));
}
}
base.VisitStructDeclaration(node);
}
catch (Exception e)
{
}
}
private StructNode GetStructNode(StructDeclarationSyntax EachStruct)
{
StructNode structnode = new StructNode();
structnode.StructName = EachStruct.Identifier.ToString();
// For each member in that class
foreach (var member in EachStruct.Members)
{
if (member is FieldDeclarationSyntax)
{
FieldDeclarationSyntax fd = member as FieldDeclarationSyntax;
foreach (var field in GetFieldNodes(fd))
{
structnode.Fields.Add(field);
}
}
else if (member is MethodDeclarationSyntax)
{
MethodDeclarationSyntax method = member as MethodDeclarationSyntax;
structnode.Methods.Add(GetMethodNode(method));
}
}
if (EachStruct.BaseList != null)
{
foreach (var baseType in EachStruct.BaseList.Types)
{
structnode.Links.Add(baseType.ToString());
}
}
return structnode;
}
private Struct TransverseStructs(StructDeclarationSyntax sds)
{
Struct retStruct = new Struct();
//public List<Delegate> Delegates { get; set; }
//public List<Method> FunctionDefs { get; set; }
//public Inheritance Inheritance { get; set; }
//public List<Module> Modules { get; set; }
//public string Name { get; set; }
//public List<Preprocessor> Preprocessors { get; set; }
//public List<Property> Properties { get; set; }
//public List<Union> Unions { get; set; }
retStruct.Name = sds.Identifier.ValueText;
if (sds.HasLeadingTrivia)
{
SetOuterComments(retStruct, sds.GetLeadingTrivia().ToFullString());
}
if (sds.HasTrailingTrivia)
{
SetInnerComments(retStruct, sds.GetTrailingTrivia().ToFullString());
}
foreach (SyntaxToken st in sds.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
retStruct.Encapsulation.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
retStruct.Qualifiers.Add(qual);
}
}
var enums = from aEnu in sds.ChildNodes().OfType<EnumDeclarationSyntax>() select aEnu;
foreach (EnumDeclarationSyntax eds in enums)
{
retStruct.Enums.Add(TraverseEnums(eds));
}
var structs = from aStruct in sds.ChildNodes().OfType<StructDeclarationSyntax>() select aStruct;
foreach (StructDeclarationSyntax sdecs in structs)
{
retStruct.Structs.Add(TransverseStructs(sdecs));
}
var methods = from aMethod in sds.ChildNodes().OfType<MethodDeclarationSyntax>() select aMethod;
foreach (MethodDeclarationSyntax mds in methods)
{
retStruct.Methods.Add(TransverseMethods(mds));
}
var fields = from aField in sds.ChildNodes().OfType<FieldDeclarationSyntax>() select aField;
foreach (FieldDeclarationSyntax fds in fields)
{
retStruct.Fields.Add(TransverseVariables(fds));
}
//var properties = from aProperty in sds.ChildNodes().OfType<PropertyDeclarationSyntax>() select aProperty;
//foreach (PropertyDeclarationSyntax pds in properties)
//{
// //traverse attributes
//}
var constructors = from aConstructor in sds.ChildNodes().OfType<ConstructorDeclarationSyntax>() select aConstructor;
foreach (ConstructorDeclarationSyntax cods in constructors)
{
retStruct.Constructors.Add(TransverseConstructors(cods));
}
var destructors = from aDestructor in sds.ChildNodes().OfType<DestructorDeclarationSyntax>() select aDestructor;
foreach (DestructorDeclarationSyntax dds in destructors)
{
retStruct.Destructors.Add(TransverseDestructors(dds));
}
var classes = from aClass in sds.ChildNodes().OfType<ClassDeclarationSyntax>() select aClass;
foreach (ClassDeclarationSyntax sds2 in classes)
{
retStruct.Classes.Add(TraverseClass(sds2));
}
return retStruct;
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
var memberNames = GetMemberNames(node);
foreach (var token in memberNames)
AddName(token);
base.VisitStructDeclaration(node);
foreach (var token in memberNames)
RemoveName(token);
}
public override void VisitStructDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax node)
{
base.VisitStructDeclaration(node);
Colorize(node.Identifier, valueTypeColor);
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
bool isUnsafe = CheckModifiers(node.Modifiers);
base.VisitStructDeclaration(node);
MarkUnsafe(node.Modifiers, isUnsafe);
}
private static StructDeclarationSyntax SortMembers(StructDeclarationSyntax type)
{
var innerMembers = type.Members.ToList();
innerMembers.Sort(StyleCop.Sort);
type = type.WithMembers(SyntaxFactory.List(innerMembers));
return type;
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
sb.AppendLine(node.Keyword.ValueText + " " + node.Identifier.ValueText);
base.VisitStructDeclaration(node);
}
public override void VisitStructDeclaration(StructDeclarationSyntax node)
{
Debug.Assert(currentScope == null);
DeclarationScope saveStaticInitScope = staticInitScope;
DeclarationScope saveInstanceInitScope = instanceInitScope;
DeclarationScope savePrimaryConstructorInitializerScope = primaryConstructorInitializerScope;
staticInitScope = new DeclarationScope(null);
DeclarationScope primaryConstructorParametersScope;
instanceInitScope = new DeclarationScope(GetPrimaryConstructorParametersScopeForInitializers(node, node.ParameterList, out primaryConstructorParametersScope));
if (primaryConstructorParametersScope == instanceInitScope.Parent)
{
primaryConstructorInitializerScope = new DeclarationScope(instanceInitScope);
}
else
{
primaryConstructorInitializerScope = new DeclarationScope(primaryConstructorParametersScope);
}
base.VisitStructDeclaration(node);
staticInitScope = saveStaticInitScope;
instanceInitScope = saveInstanceInitScope;
primaryConstructorInitializerScope = savePrimaryConstructorInitializerScope;
Debug.Assert(currentScope == null);
}
public override SyntaxNode VisitStructDeclaration(StructDeclarationSyntax node)
{
if (node == null)
return null;
var symbol = m_model.GetDeclaredSymbol(node);
node = (StructDeclarationSyntax)base.VisitStructDeclaration(node);
if (!IsPrivateOrInternal(symbol.DeclaredAccessibility))
node = (StructDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId());
return node;
}
public void Add(StructDeclarationSyntax node)
{
//throw new NotImplementedException();
// nothing technically to do here atm?
}
