private static IEnumerable <AttributeListSyntax> BuildColumnAttributes(IDatabaseColumn column, string propertyName)
{
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
if (propertyName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(propertyName));
}
if (propertyName == column.Name.LocalName)
{
return(Array.Empty <AttributeListSyntax>());
}
return(new[]
{
AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(AliasAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(column.Name.LocalName)))))))
)
});
}
public static SyntaxTrivia Scan(SlidingTextWindow TextWindow)
{
char xcNextChar = TextWindow.PeekCharacter();
switch (xcNextChar)
{
case '\r':
if (TextWindow.PeekCharacter(1) == '\n')
{
TextWindow.SkipAhead(2);
return(SyntaxFactory.EndOfLine("\r\n"));
}
return(SyntaxFactory.EndOfLine("\r"));
case '\n':
TextWindow.SkipAhead(1);
return(SyntaxFactory.EndOfLine("\n"));
default:
// Try again
if (SyntaxUtilities.IsNewLineCharacter(xcNextChar))
{
TextWindow.SkipAhead(1);
return(SyntaxFactory.EndOfLine("\n"));
}
return(null);
}
}
public override void VisitMarkupMinimizedAttributeBlock(MarkupMinimizedAttributeBlockSyntax node)
{
WriteBlock(node, FormattingBlockKind.Markup, n =>
{
var mergedAttributePrefix = SyntaxUtilities.MergeTextLiterals(node.NamePrefix, node.Name);
Visit(mergedAttributePrefix);
});
}
/// <summary>
/// Scans through the window and generates a WhiteSpace SyntaxNode/Trivia
/// </summary>
/// <param name="TextWindow"></param>
/// <returns></returns>
public static SyntaxTrivia Scan(SlidingTextWindow TextWindow)
{
// Default to OnlyWhiteSpace true
Boolean bIsOnlySpaces = true;
Boolean bEndOfTrivia = false;
String sCharactersScannedSoFar = String.Empty;
while (!bEndOfTrivia && TextWindow.HasCharactersLeftToProcess())
{
// Peek at a character
char ch = TextWindow.PeekCharacter();
switch (ch)
{
case '\t': // Horizontal tab
case '\v': // Vertical Tab
case '\f': // Form-feed
case '\u001A':
bIsOnlySpaces = false;
goto case ' ';
case ' ':
sCharactersScannedSoFar += TextWindow.PopCharacter();
break;
case '\r': // Carriage Return
case '\n': // Line-feed
// End iteration
bEndOfTrivia = true;
break;
default:
if (ch > 127 && SyntaxUtilities.IsWhiteSpace(ch))
{
goto case '\t';
}
bEndOfTrivia = true;
break;
}
}
// Return the specific instance where possible
if (sCharactersScannedSoFar.Length == 0)
{
return(null);
}
if (bIsOnlySpaces && sCharactersScannedSoFar.Length == 1)
{
return(SyntaxFactory.Space);
}
else
{
return(SyntaxFactory.WhiteSpace(sCharactersScannedSoFar));
}
}
public override SyntaxNode VisitMarkupStartTag(MarkupStartTagSyntax node)
{
SpanContext latestSpanContext = null;
var newChildren = SyntaxListBuilder <RazorSyntaxNode> .Create();
var literals = new List <MarkupTextLiteralSyntax>();
foreach (var child in node.Children)
{
if (child is MarkupTextLiteralSyntax literal)
{
literals.Add(literal);
latestSpanContext = literal.GetSpanContext() ?? latestSpanContext;
}
else if (child is MarkupMiscAttributeContentSyntax miscContent)
{
foreach (var contentChild in miscContent.Children)
{
if (contentChild is MarkupTextLiteralSyntax contentLiteral)
{
literals.Add(contentLiteral);
latestSpanContext = contentLiteral.GetSpanContext() ?? latestSpanContext;
}
else
{
// Pop stack
AddLiteralIfExists();
newChildren.Add(contentChild);
}
}
}
else
{
AddLiteralIfExists();
newChildren.Add(child);
}
}
AddLiteralIfExists();
return(SyntaxFactory.MarkupStartTag(newChildren.ToList()).Green.CreateRed(node.Parent, node.Position));
void AddLiteralIfExists()
{
if (literals.Count > 0)
{
var mergedLiteral = SyntaxUtilities.MergeTextLiterals(literals.ToArray());
mergedLiteral = mergedLiteral.WithSpanContext(latestSpanContext);
literals.Clear();
latestSpanContext = null;
newChildren.Add(mergedLiteral);
}
}
}
private void VerifySyntaxMap(string oldSource, string newSource)
{
var oldRoot = SyntaxFactory.ParseSyntaxTree(oldSource).GetRoot();
var newRoot = SyntaxFactory.ParseSyntaxTree(newSource).GetRoot();
foreach (var oldNode in oldRoot.DescendantNodes().Where(n => n.FullSpan.Length > 0))
{
var newNode = SyntaxUtilities.FindPartner(oldRoot, newRoot, oldNode);
Assert.True(SyntaxFactory.AreEquivalent(oldNode, newNode), $"Node '{oldNode}' not equivalent to '{newNode}'.");
}
}
public override void VisitMarkupAttributeBlock(MarkupAttributeBlockSyntax node)
{
WriteBlock(node, FormattingBlockKind.Markup, n =>
{
var equalsSyntax = SyntaxFactory.MarkupTextLiteral(new SyntaxList <SyntaxToken>(node.EqualsToken));
var mergedAttributePrefix = SyntaxUtilities.MergeTextLiterals(node.NamePrefix, node.Name, node.NameSuffix, equalsSyntax, node.ValuePrefix);
Visit(mergedAttributePrefix);
Visit(node.Value);
Visit(node.ValueSuffix);
});
}
private static IEnumerable <AttributeListSyntax> BuildClassAttributes(IRelationalDatabaseTable table, string className)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (className.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(className));
}
var attributes = new List <AttributeListSyntax>();
if (className != table.Name.LocalName)
{
var attributeArguments = new List <AttributeArgumentSyntax>
{
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(table.Name.LocalName)))
};
var schemaName = table.Name.Schema;
if (!schemaName.IsNullOrWhiteSpace())
{
var schemaArgument = AttributeArgument(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(TableAttribute.Schema)),
Token(SyntaxKind.EqualsToken),
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(schemaName))));
attributeArguments.Add(schemaArgument);
}
var tableAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(TableAttribute)),
AttributeArgumentList(
SeparatedList(attributeArguments)))));
attributes.Add(tableAttribute);
}
return(attributes);
}
private static IEnumerable <AttributeListSyntax> BuildClassAttributes(IDatabaseView view, string className)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
if (className.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(className));
}
var attributes = new List <AttributeListSyntax>();
var schemaName = view.Name.Schema;
if (!schemaName.IsNullOrWhiteSpace())
{
var schemaAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(SchemaAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(schemaName))))))));
attributes.Add(schemaAttribute);
}
if (className != view.Name.LocalName)
{
var aliasAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(AliasAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(view.Name.LocalName))))))));
attributes.Add(aliasAttribute);
}
return(attributes);
}
private static SyntaxTriviaList BuildDbSetComment(string targetName, string objectType)
{
if (targetName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(targetName));
}
if (objectType.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(objectType));
}
return(SyntaxUtilities.BuildCommentTrivia(new XmlNodeSyntax[]
{
XmlText("Accesses the "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(targetName))),
XmlText(" " + objectType + ".")
}));
}
private static SyntaxTriviaList BuildTableComment(Identifier tableName, Option <IRelationalDatabaseTableComments> comment)
{
if (tableName == null)
{
throw new ArgumentNullException(nameof(tableName));
}
return(comment
.Bind(c => c.Comment)
.Match(
SyntaxUtilities.BuildCommentTrivia,
() => SyntaxUtilities.BuildCommentTrivia(new XmlNodeSyntax[]
{
XmlText("A mapping class to query the "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(tableName.LocalName))),
XmlText(" table.")
})
));
}
private static SyntaxTriviaList BuildColumnComment(Identifier columnName, Option <IRelationalDatabaseTableComments> comment)
{
if (columnName == null)
{
throw new ArgumentNullException(nameof(columnName));
}
return(comment
.Bind(c => c.ColumnComments.TryGetValue(columnName, out var cc) ? cc : Option <string> .None)
.Match(
SyntaxUtilities.BuildCommentTrivia,
() => SyntaxUtilities.BuildCommentTrivia(new XmlNodeSyntax[]
{
XmlText("The "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(columnName.LocalName))),
XmlText(" column.")
})
));
}
private static IEnumerable <AttributeListSyntax> BuildColumnAttributes(IDatabaseColumn column, string propertyName)
{
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
if (propertyName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(propertyName));
}
var columnAttributeArgs = new List <AttributeArgumentSyntax>();
if (propertyName != column.Name.LocalName)
{
var quotedColumnName = LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(column.Name.LocalName));
columnAttributeArgs.Add(AttributeArgument(quotedColumnName));
}
columnAttributeArgs.Add(
AttributeArgument(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(ColumnAttribute.TypeName)),
Token(SyntaxKind.EqualsToken),
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(column.Type.TypeName.LocalName)))));
return(new[]
{
AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(ColumnAttribute)),
AttributeArgumentList(
SeparatedList(columnAttributeArgs)))))
});
}
private static SyntaxTriviaList BuildChildKeyComment(IDatabaseRelationalKey relationalKey)
{
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
var hasChildKeyName = relationalKey.ChildKey.Name.IsSome;
var foreignKeyNameNode = relationalKey.ChildKey.Name.Match(
name => XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(name.LocalName))),
() => XmlText(string.Empty) as XmlNodeSyntax
);
return(SyntaxUtilities.BuildCommentTrivia(new XmlNodeSyntax[]
{
XmlText("The" + (hasChildKeyName ? " " : string.Empty)),
foreignKeyNameNode,
XmlText(" child key. Navigates from "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ParentTable.LocalName))),
XmlText(" to "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ChildTable.LocalName))),
XmlText(".")
}));
}
private static SyntaxTriviaList BuildForeignKeyComment(IDatabaseRelationalKey relationalKey, Option <IRelationalDatabaseTableComments> comment)
{
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
var hasChildKeyName = relationalKey.ChildKey.Name.IsSome;
return(comment
.Bind(c => relationalKey.ChildKey.Name
.Match(
ckName => c.ForeignKeyComments.TryGetValue(ckName, out var fkc) ? fkc : Option <string> .None,
() => Option <string> .None))
.Match(
SyntaxUtilities.BuildCommentTrivia,
() =>
{
var foreignKeyNameNode = relationalKey.ChildKey.Name.Match(
name => XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(name.LocalName))),
() => XmlText(string.Empty) as XmlNodeSyntax
);
return SyntaxUtilities.BuildCommentTrivia(new XmlNodeSyntax[]
{
XmlText("The" + (hasChildKeyName ? " " : string.Empty)),
foreignKeyNameNode,
XmlText(" foreign key. Navigates from "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ChildTable.LocalName))),
XmlText(" to "),
XmlElement("c", SingletonList <XmlNodeSyntax>(XmlText(relationalKey.ParentTable.LocalName))),
XmlText(".")
});
}
));
}
private ClassDeclarationSyntax GeneratePartialClass(INamedTypeSymbol engineInterface)
{
var className = "ScriptIterativeInterpreter";
var interfaceMembers = engineInterface.GetMembers().OfType <IMethodSymbol>();
var implMembers = new List <MemberDeclarationSyntax>();
var implementations = new List <(int, string)>();
foreach (var mem in interfaceMembers)
{
var attrs = mem.GetAttributes();
var implAttr = attrs.FirstOrDefault(a => a.AttributeClass.Name == "ScriptImplementationAttribute");
if (implAttr == null)
{
continue;
}
var opCode = (int)implAttr.ConstructorArguments[0].Value;
var body = new List <StatementSyntax>();
// Dequeue argument expressions from TopFrame's locals
foreach (var param in mem.Parameters)
{
if (param.HasExplicitDefaultValue)
{
body.Add(LocalDeclarationStatement(VariableDeclaration(ParseTypeName("InterpreterResult")).WithVariables(
SingletonSeparatedList(VariableDeclarator(Identifier(param.Name))
.WithInitializer(EqualsValueClause(LiteralExpression(
SyntaxKind.DefaultLiteralExpression,
Token(SyntaxKind.DefaultKeyword))))))));
body.Add(IfStatement(
BinaryExpression(SyntaxKind.GreaterThanExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("state"),
IdentifierName("TopFrame")),
IdentifierName("Locals")),
IdentifierName("Count")),
SyntaxUtilities.LiteralExpression(0)),
ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, IdentifierName(param.Name),
InvocationExpression(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("state"),
IdentifierName("TopFrame")),
IdentifierName("Locals")),
IdentifierName("Dequeue")))))
));
}
else
{
body.Add(LocalDeclarationStatement(VariableDeclaration(IdentifierName("var")).WithVariables(
SingletonSeparatedList(VariableDeclarator(Identifier(param.Name))
.WithInitializer(EqualsValueClause(
InvocationExpression(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("state"),
IdentifierName("TopFrame")),
IdentifierName("Locals")),
IdentifierName("Dequeue")))))))));
}
}
// Ensure that we're done with the available arguments
body.Add(ExpressionStatement(
InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("Debug"),
IdentifierName("Assert")))
.AddArgumentListArguments(
Argument(
BinaryExpression(SyntaxKind.EqualsExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("state"),
IdentifierName("TopFrame")),
IdentifierName("Locals")),
IdentifierName("Count")),
LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0)))))));
// Invoke implementation with properly typed arguments
var invoke = InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName("scriptEngine")),
IdentifierName(mem.Name)));
foreach (var param in mem.Parameters)
{
invoke = invoke.AddArgumentListArguments(Argument(GetValueForParam(param)));
}
if (mem.ReturnType.SpecialType == SpecialType.System_Void)
{
body.Add(ExpressionStatement(invoke));
}
else
{
body.Add(LocalDeclarationStatement(
VariableDeclaration(IdentifierName("var"))
.AddVariables(VariableDeclarator(Identifier("result"))
.WithInitializer(
EqualsValueClause(invoke)))));
}
body.Add(CreateInterpreterResult(mem.ReturnType));
var implName = "Invoke_" + mem.Name + "_" + opCode;
implementations.Add((opCode, implName));
implMembers.Add(MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)), implName)
.WithBody(Block(body))
.AddParameterListParameters(
Parameter(Identifier("state"))
.WithModifiers(TokenList(Token(SyntaxKind.RefKeyword)))
.WithType(IdentifierName("InterpreterState"))));
}
implMembers.Add(CreateDispatchImplementation(implementations.OrderBy(i => i.Item1).ToList()));
var cls = ClassDeclaration(className).WithModifiers(TokenList(Token(SyntaxKind.PartialKeyword)))
.WithMembers(List(implMembers));
return(cls);
}
private static IEnumerable <AttributeListSyntax> BuildColumnAttributes(IDatabaseColumn column, string propertyName)
{
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
if (propertyName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(propertyName));
}
var attributes = new List <AttributeListSyntax>();
var clrType = column.Type.ClrType;
var isConstrainedType = clrType == typeof(string) || clrType == typeof(byte[]);
if (isConstrainedType && column.Type.MaxLength > 0)
{
var maxLengthAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(MaxLengthAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(column.Type.MaxLength))))))));
attributes.Add(maxLengthAttribute);
}
if (!clrType.IsValueType && !column.IsNullable)
{
var requiredAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(RequiredAttribute)))));
attributes.Add(requiredAttribute);
}
column.AutoIncrement.IfSome(_ =>
{
var databaseGeneratedAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(DatabaseGeneratedAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(nameof(DatabaseGeneratedOption)),
IdentifierName(nameof(DatabaseGeneratedOption.Identity)))))))));
attributes.Add(databaseGeneratedAttribute);
});
var columnAttributeArgs = new List <AttributeArgumentSyntax>();
if (propertyName != column.Name.LocalName)
{
var quotedColumnName = LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(column.Name.LocalName));
columnAttributeArgs.Add(AttributeArgument(quotedColumnName));
}
columnAttributeArgs.Add(
AttributeArgument(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(ColumnAttribute.TypeName)),
Token(SyntaxKind.EqualsToken),
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(column.Type.TypeName.LocalName))))
);
var columnAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(ColumnAttribute)),
AttributeArgumentList(
SeparatedList(columnAttributeArgs)))));
attributes.Add(columnAttribute);
return(attributes);
}
private static SyntaxList <RazorSyntaxNode> GetRewrittenMarkupStartTagChildren(MarkupStartTagSyntax node)
{
// Rewrites the children of the start tag to look like the legacy syntax tree.
if (node.IsMarkupTransition)
{
var tokens = node.DescendantNodes().Where(n => n is SyntaxToken token && !token.IsMissing).Cast <SyntaxToken>().ToArray();
var tokenBuilder = SyntaxListBuilder <SyntaxToken> .Create();
tokenBuilder.AddRange(tokens, 0, tokens.Length);
var markupTransition = SyntaxFactory.MarkupTransition(tokenBuilder.ToList()).Green.CreateRed(node, node.Position);
var spanContext = node.GetSpanContext();
if (spanContext != null)
{
markupTransition = markupTransition.WithSpanContext(spanContext);
}
var builder = new SyntaxListBuilder(1);
builder.Add(markupTransition);
return(new SyntaxList <RazorSyntaxNode>(builder.ToListNode().CreateRed(node, node.Position)));
}
SpanContext latestSpanContext = null;
var children = node.Children;
var newChildren = new SyntaxListBuilder(children.Count);
var literals = new List <MarkupTextLiteralSyntax>();
foreach (var child in children)
{
if (child is MarkupTextLiteralSyntax literal)
{
literals.Add(literal);
latestSpanContext = literal.GetSpanContext() ?? latestSpanContext;
}
else if (child is MarkupMiscAttributeContentSyntax miscContent)
{
foreach (var contentChild in miscContent.Children)
{
if (contentChild is MarkupTextLiteralSyntax contentLiteral)
{
literals.Add(contentLiteral);
latestSpanContext = contentLiteral.GetSpanContext() ?? latestSpanContext;
}
else
{
// Pop stack
AddLiteralIfExists();
newChildren.Add(contentChild);
}
}
}
else
{
AddLiteralIfExists();
newChildren.Add(child);
}
}
AddLiteralIfExists();
return(new SyntaxList <RazorSyntaxNode>(newChildren.ToListNode().CreateRed(node, node.Position)));
void AddLiteralIfExists()
{
if (literals.Count > 0)
{
var mergedLiteral = SyntaxUtilities.MergeTextLiterals(literals.ToArray());
mergedLiteral = mergedLiteral.WithSpanContext(latestSpanContext);
literals.Clear();
latestSpanContext = null;
newChildren.Add(mergedLiteral);
}
}
}
private IEnumerable <AttributeListSyntax> BuildClassAttributes(IRelationalDatabaseTable table, string className)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (className.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(className));
}
var attributes = new List <AttributeListSyntax>();
var schemaName = table.Name.Schema;
if (!schemaName.IsNullOrWhiteSpace())
{
var schemaAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(SchemaAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(schemaName))))))));
attributes.Add(schemaAttribute);
}
if (className != table.Name.LocalName)
{
var aliasAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(AliasAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(table.Name.LocalName))))))));
attributes.Add(aliasAttribute);
}
var multiColumnUniqueKeys = table.UniqueKeys.Where(uk => uk.Columns.Skip(1).Any()).ToList();
foreach (var uniqueKey in multiColumnUniqueKeys)
{
var columnNames = uniqueKey.Columns
.Select(c => NameTranslator.ColumnToPropertyName(className, c.Name.LocalName))
.Select(p => AttributeArgument(
InvocationExpression(
IdentifierName(
Identifier(
TriviaList(),
SyntaxKind.NameOfKeyword,
"nameof",
"nameof",
TriviaList())),
ArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(p)))))));
var uniqueConstraintAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(UniqueConstraintAttribute)),
AttributeArgumentList(
SeparatedList(columnNames)))));
attributes.Add(uniqueConstraintAttribute);
}
var multiColumnIndexes = table.Indexes.Where(ix => ix.Columns.Skip(1).Any()).ToList();
foreach (var index in multiColumnIndexes)
{
var indexColumns = index.Columns;
var dependentColumns = indexColumns.SelectMany(ic => ic.DependentColumns).ToList();
if (dependentColumns.Count > indexColumns.Count)
{
continue;
}
var attrParams = dependentColumns
.Select(c => NameTranslator.ColumnToPropertyName(className, c.Name.LocalName))
.Select(p => AttributeArgument(
InvocationExpression(
IdentifierName(
Identifier(
TriviaList(),
SyntaxKind.NameOfKeyword,
"nameof",
"nameof",
TriviaList())),
ArgumentList(
SingletonSeparatedList(
Argument(
IdentifierName(p))))
)
))
.ToList();
if (index.IsUnique)
{
var uniqueTrueArgument = AttributeArgument(
LiteralExpression(SyntaxKind.TrueLiteralExpression)
);
attrParams = new[] { uniqueTrueArgument }.Concat(attrParams).ToList();
}
var compositeIndexAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(CompositeIndexAttribute)),
AttributeArgumentList(
SeparatedList(attrParams)))));
attributes.Add(compositeIndexAttribute);
}
return(attributes);
}
private IEnumerable <AttributeListSyntax> BuildColumnAttributes(IRelationalDatabaseTable table, IDatabaseColumn column, string propertyName)
{
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
if (propertyName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(propertyName));
}
var attributes = new List <AttributeListSyntax>();
var clrType = column.Type.ClrType;
if (clrType == typeof(string) && column.Type.MaxLength > 0)
{
var maxLengthAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(StringLengthAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(column.Type.MaxLength))))))));
attributes.Add(maxLengthAttribute);
}
if (!clrType.IsValueType && !column.IsNullable)
{
var requiredAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(RequiredAttribute)))));
attributes.Add(requiredAttribute);
}
var isPrimaryKey = ColumnIsPrimaryKey(table, column);
if (isPrimaryKey)
{
var primaryKeyAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(PrimaryKeyAttribute)))));
attributes.Add(primaryKeyAttribute);
}
if (column.AutoIncrement.IsSome)
{
var autoIncrementAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(AutoIncrementAttribute)))));
attributes.Add(autoIncrementAttribute);
}
var isNonUniqueIndex = ColumnIsNonUniqueIndex(table, column);
var isUniqueIndex = ColumnIsUniqueIndex(table, column);
var isIndex = isNonUniqueIndex || isUniqueIndex;
if (isIndex)
{
var indexAttribute = Attribute(
SyntaxUtilities.AttributeName(nameof(IndexAttribute))
);
var indexAttributeList = AttributeList(SingletonSeparatedList(indexAttribute));
if (isNonUniqueIndex)
{
attributes.Add(indexAttributeList);
}
else
{
var uniqueIndexAttribute = indexAttribute
.WithArgumentList(
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(SyntaxKind.TrueLiteralExpression)))));
var uniqueIndexAttributeList = AttributeList(SingletonSeparatedList(uniqueIndexAttribute));
attributes.Add(uniqueIndexAttributeList);
}
}
var isUniqueKey = ColumnIsUniqueKey(table, column);
if (isUniqueKey)
{
var uniqueKeyAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(UniqueAttribute)))));
attributes.Add(uniqueKeyAttribute);
}
column.DefaultValue.IfSome(def =>
{
var defaultAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(DefaultAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(def))))))));
attributes.Add(defaultAttribute);
});
var isForeignKey = ColumnIsForeignKey(table, column);
if (isForeignKey)
{
var relationalKey = ColumnRelationalKey(table, column);
if (relationalKey == null)
{
throw new InvalidOperationException("Could not find parent key for foreign key relationship. Expected to find one for " + column.Name.LocalName + "." + column.Name.LocalName);
}
var parentTable = relationalKey.ParentTable;
var parentClassName = NameTranslator.TableToClassName(parentTable);
// TODO check that this is not implicit -- i.e. there is a naming convention applied
// so explicitly declaring via [References(...)] may not be necessary
var fkAttributeArgs = new List <AttributeArgumentSyntax>
{
AttributeArgument(TypeOfExpression(ParseTypeName(parentClassName)))
};
relationalKey.ChildKey.Name.IfSome(fkName =>
{
var foreignKeyNameArg = AttributeArgument(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(ForeignKeyAttribute.ForeignKeyName)),
Token(SyntaxKind.EqualsToken),
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(fkName.LocalName))));
fkAttributeArgs.Add(foreignKeyNameArg);
});
if (relationalKey.DeleteAction != ReferentialAction.NoAction)
{
var deleteAction = ForeignKeyAction[relationalKey.DeleteAction];
var foreignKeyOnDeleteArg = AttributeArgument(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(ForeignKeyAttribute.OnDelete)),
Token(SyntaxKind.EqualsToken),
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(deleteAction))));
fkAttributeArgs.Add(foreignKeyOnDeleteArg);
}
if (relationalKey.UpdateAction != ReferentialAction.NoAction)
{
var updateAction = ForeignKeyAction[relationalKey.UpdateAction];
var foreignKeyOnUpdateArg = AttributeArgument(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(ForeignKeyAttribute.OnUpdate)),
Token(SyntaxKind.EqualsToken),
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(updateAction))));
fkAttributeArgs.Add(foreignKeyOnUpdateArg);
}
var foreignKeyAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(ForeignKeyAttribute)),
AttributeArgumentList(SeparatedList(fkAttributeArgs)))));
attributes.Add(foreignKeyAttribute);
}
if (propertyName != column.Name.LocalName)
{
var aliasAttribute = AttributeList(
SingletonSeparatedList(
Attribute(
SyntaxUtilities.AttributeName(nameof(AliasAttribute)),
AttributeArgumentList(
SingletonSeparatedList(
AttributeArgument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(column.Name.LocalName))))))));
attributes.Add(aliasAttribute);
}
return(attributes);
}
/// <summary>
/// Used to analyse the current textwindow and retrieve/skip any
/// trivia which includes things such as whitespace, newlines,
/// comments and multi-line comments
/// Returns them as a flat list
/// </summary>
/// <param name="bIsTrailing"></param>
/// <returns></returns>
private List <SyntaxTrivia> LexSyntaxTrivia(Boolean bIsTrailing = false)
{
// Initialise variables
List <SyntaxTrivia> aoReturnList = new List <SyntaxTrivia>();
Boolean bNewLineCharFound = false;
// Just keep lexing until we are told to stop
// or we run out of characters to process
while (TextWindow.HasCharactersLeftToProcess())
{
// Check the next character and switch based on that
char xcNextChar = TextWindow.PeekCharacter();
if (SyntaxUtilities.IsWhiteSpace(xcNextChar))
{
// Try and scan the item
SyntaxTrivia oNewItem = WhiteSpaceScanner.Scan(TextWindow);
// Insert it
aoReturnList.Add(oNewItem);
}
else if (SyntaxUtilities.IsNewLineCharacter(xcNextChar))
{
bNewLineCharFound = true;
// Do not steal trailing comments if a newline has been found
if (bIsTrailing)
{
break;
}
// Try and scan the item
SyntaxTrivia oNewItem = NewLineScanner.Scan(TextWindow);
// Insert it
aoReturnList.Add(oNewItem);
}
// Handle Comments
else if (xcNextChar == '-')
{
// Do not touch a single -, only play with --
if (TextWindow.PeekCharacter(1) != '-')
{
return(aoReturnList);
}
// Only pick up inlines if they are directly trailing an item
// Do not steal another nodes leading comments
if (bNewLineCharFound && bIsTrailing)
{
break;
}
SyntaxTrivia oComment = CommentScanner.ScanSingleLineComment(TextWindow);
aoReturnList.Add(oComment);
}
else if (xcNextChar == '/')
{
// Do not touch a single /, only play with /*
if (TextWindow.PeekCharacter(1) != '*')
{
return(aoReturnList);
}
// Do not steal trailing comments if a newline has been found
if (bNewLineCharFound && bIsTrailing)
{
break;
}
SyntaxTrivia oComment = CommentScanner.ScanMultiLineComment(TextWindow);
aoReturnList.Add(oComment);
}
else
{
break;
}
}
return(aoReturnList);
}
public static SyntaxTrivia ScanSingleLineComment(SlidingTextWindow TextWindow)
{
// Check next char
char xcNextChar = TextWindow.PeekCharacter();
// If it is two hypens together
if (xcNextChar == '-' && TextWindow.PeekCharacter(1) == '-')
{
// Ignore Comment syntax (we just want text)
TextWindow.SkipAhead(2);
Boolean bIsCommentTerminated = false;
String sCommentLine = String.Empty;
// Iterate indefinitely until we reach the end
for (int iIndex = 0; TextWindow.Position + iIndex < TextWindow.Count; iIndex++)
{
// NewLine char (Terminated properly)
if (SyntaxUtilities.IsNewLineCharacter(TextWindow.PeekCharacter(iIndex)))
{
// Break the loop and the comment is terminated properly
bIsCommentTerminated = true;
break;
}
// Keep adding characters to our intermediate var
sCommentLine += TextWindow.PeekCharacter(iIndex);
}
// Just advance the length of the text (we can't fix peoples comments 100%
// of the time)
TextWindow.SkipAhead(sCommentLine.Length);
// If our comment was terminated properly
if (bIsCommentTerminated)
{
return(SyntaxFactory.SingleLineComment(sCommentLine));
}
// Not terminated properly.. (hardest case)
// If we reach the end of the window its either an EOF comment (which is unlikely)
// or it is an unterminated comment
else
{
// Intermediate Var (Add all the text as a comment)
SyntaxTrivia oCommentNode = SyntaxFactory.SingleLineComment(sCommentLine);
// Add the erroraneous message
oCommentNode.Comments.Add(ErrorMessageLibrary.GetErrorMessage(8002, "Single Line Comment"));
// return the comment node with everything in comments
return(oCommentNode);
}
}
// This token should not be here (there is something wrong)
// Intermediate Var (Add all the text as a comment)
SyntaxTrivia oErraneousToken = new SyntaxTrivia(
SyntaxKind.UnknownNode, // Unknown
Convert.ToString(TextWindow.PeekCharacter())); // Get the character out of the stream
oErraneousToken.Comments.Add(ErrorMessageLibrary.GetErrorMessage(8001, Convert.ToString(TextWindow.PopCharacter())));
// return the comment node with everything in comments
return(oErraneousToken);
}
