private MemberDeclarationSyntax WrapInNamespace(XSharpTreeTransformationCore trans, MemberDeclarationSyntax member,
XP.Namespace_Context xns, string defaultNamespace)
{
if (xns != null || !String.IsNullOrEmpty(defaultNamespace))
{
var members = _pool.Allocate <MemberDeclarationSyntax>();
string nsName;
if (xns != null)
{
nsName = GetNsFullName(xns);
}
else
{
nsName = defaultNamespace;
}
members.Add(member);
member = _syntaxFactory.NamespaceDeclaration(SyntaxFactory.MakeToken(SyntaxKind.NamespaceKeyword),
name: trans.GenerateQualifiedName(nsName),
openBraceToken: SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken),
externs: null,
usings: null,
members: members,
closeBraceToken: SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken),
semicolonToken: SyntaxFactory.MakeToken(SyntaxKind.SemicolonToken));
_pool.Free(members);
}
return(member);
}
private List <MemberDeclarationSyntax> GeneratePartialProperties(List <PartialPropertyElement> classes,
SyntaxListBuilder <UsingDirectiveSyntax> usingslist, XSharpTreeTransformationCore trans)
{
// Create a list of member declarations for all partial types
// that do not have a constructor (when /vo16 is selected)
// or where access and assign were not found in the same source file
// the usingList will contain an unique list of using statements combined from the various
// source files where the types were found.
var dict = new Dictionary <string, List <XP.IMethodContext> >(XSharpString.Comparer);
var tmpUsings = new List <Syntax.UsingDirectiveSyntax>();
foreach (var clsctx in classes)
{
if (clsctx.Type.PartialProperties != null)
{
foreach (var m in clsctx.Type.PartialProperties)
{
var idName = m.Id.Get <SyntaxToken>();
var name = idName.Text;
if (dict.ContainsKey(name))
{
dict[name].Add(m);
}
else
{
var list = new List <XP.IMethodContext>()
{
m
};
dict.Add(name, list);
}
}
// Collect quickly now. Deduplicate later.
tmpUsings.AddRange(clsctx.Usings);
}
}
// now we have a list of PropertyNames and methods
var result = new List <MemberDeclarationSyntax>();
// add the usings when they are not in the list yet
foreach (var u in tmpUsings)
{
var green = u.Green as UsingDirectiveSyntax;
trans.AddUsingWhenMissing(usingslist, green.Name, green.StaticKeyword != null, green.Alias);
}
// For each unique name add a property
foreach (var element in dict)
{
var prop = new XSharpTreeTransformationCore.SyntaxClassEntities.VoPropertyInfo();
prop.idName = SyntaxFactory.Identifier(element.Key);
foreach (var m in element.Value)
{
if (m.RealType == XSharpLexer.ACCESS)
{
if (prop.AccessMethodCtx == null)
{
prop.AccessMethodCtx = m;
}
else
{
prop.DupAccess = m;
}
}
else
{
if (prop.AssignMethodCtx == null)
{
prop.AssignMethodCtx = m;
}
else
{
prop.DupAssign = m;
}
}
}
var propdecl = trans.GenerateVoProperty(prop, null);
result.Add(propdecl);
}
return(result);
}
private ClassDeclarationSyntax _generatePszClass(Dictionary <string, Tuple <string, FieldDeclarationSyntax> > fields, XSharpTreeTransformationCore trans)
{
var clsmembers = _pool.Allocate <MemberDeclarationSyntax>();
foreach (var field in fields)
{
var fieldDecl = field.Value.Item2;
clsmembers.Add(fieldDecl);
}
var decl = _syntaxFactory.ClassDeclaration(
default(SyntaxList <AttributeListSyntax>),
trans.TokenList(SyntaxKind.StaticKeyword, SyntaxKind.InternalKeyword),
SyntaxFactory.MakeToken(SyntaxKind.ClassKeyword),
SyntaxFactory.MakeIdentifier(XSharpSpecialNames.PSZTable),
default(TypeParameterListSyntax),
default(BaseListSyntax),
default(SyntaxList <TypeParameterConstraintClauseSyntax>),
SyntaxFactory.MakeToken(SyntaxKind.OpenBraceToken),
clsmembers,
SyntaxFactory.MakeToken(SyntaxKind.CloseBraceToken),
null);
fields.Clear();
return(decl);
}
