public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false)
{
string text = id.ValueText;
var keywordKind = SyntaxFacts.GetKeywordKind(text);
if (keywordKind != Microsoft.CodeAnalysis.CSharp.SyntaxKind.None)
{
return(SyntaxFactory.Identifier("@" + text));
}
if (id.SyntaxTree == _semanticModel.SyntaxTree)
{
var symbol = _semanticModel.GetSymbolInfo(id.Parent).Symbol;
if (symbol != null && !String.IsNullOrWhiteSpace(symbol.Name))
{
if (symbol.IsConstructor() && isAttribute)
{
text = symbol.ContainingType.Name;
if (text.EndsWith("Attribute", StringComparison.Ordinal))
{
text = text.Remove(text.Length - "Attribute".Length);
}
}
else if (text.StartsWith("_", StringComparison.Ordinal) && symbol is IFieldSymbol fieldSymbol && fieldSymbol.AssociatedSymbol?.IsKind(SymbolKind.Property) == true)
{
text = fieldSymbol.AssociatedSymbol.Name;
}
}
}
return(SyntaxFactory.Identifier(text));
}
/// <summary>
/// public static bool IsTruthy(int i)
/// </summary>
/// <returns></returns>
internal static MethodDeclarationSyntax IsTruthyMethodInt()
{
return
(SF.MethodDeclaration(
new SyntaxList <AttributeListSyntax>(),
SF.TokenList(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword)),
SF.PredefinedType(SF.Token(SyntaxKind.BoolKeyword)),
default(ExplicitInterfaceSpecifierSyntax),
SF.Identifier("IsTruthy"),
default(TypeParameterListSyntax),
SF.ParameterList(new SeparatedSyntaxList <ParameterSyntax>().Add(SyntaxFactory.Parameter(
default(SyntaxList <AttributeListSyntax>),
default(SyntaxTokenList),
SF.PredefinedType(SF.Token(SyntaxKind.IntKeyword)),
SF.Identifier("i"),
default(EqualsValueClauseSyntax)))
),
default(SyntaxList <TypeParameterConstraintClauseSyntax>),
SF.Block(
SF.ReturnStatement(SF.ParseExpression("i!=0"))
),
default(SyntaxToken)
));
}
private static MethodDeclarationSyntax MakeWithMethod(
TypeDeclarationSyntax type, IEnumerable <Field> fields, MethodDeclarationSyntax maybePreviousWithMethod)
{
var fieldsList = fields.ToList();
var withMethodParameters = SF.ParameterList(
SF.SeparatedList(
fieldsList.Select(
field => SF.Parameter(SF.Identifier(field.Name))
.WithType(field.IsNonNullable ? SF.NullableType(field.Type) : field.Type)
.WithDefault(
SF.EqualsValueClause(
SF.Token(SyntaxKind.EqualsToken),
SF.LiteralExpression(SyntaxKind.NullLiteralExpression)
)
)
.WithAttributeLists(field.Attributes)
)
)
);
var withMethodBodyStatements = fieldsList.Select(
field => SF.Argument(
SF.BinaryExpression(
SyntaxKind.CoalesceExpression, SF.IdentifierName(field.Name),
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name)
)
)
)
);
var previousAttributes = maybePreviousWithMethod?.AttributeLists ?? new SyntaxList <AttributeListSyntax>();
var typeSyntax = TypeSyntaxFactory.GetTypeSyntax(
type.Identifier.Text, type.TypeParameterList?.Parameters.Select(x => x.Identifier.Text).ToArray()
);
var res = SF.MethodDeclaration(typeSyntax, "With")
.WithAttributeLists(previousAttributes)
.WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) }))
.WithParameterList(withMethodParameters)
.WithBody(
SF.Block(
SF.ReturnStatement(
SF.ObjectCreationExpression(
typeSyntax, SF.ArgumentList(SF.SeparatedList(withMethodBodyStatements)), null
)
)
)
);
res = fieldsList.Any(x => x.StructuredTrivia != null) ? res.WithLeadingTrivia(
MakeXmlDocComments(maybePreviousWithMethod, fieldsList, Constants.DefaultModifierSummary)
) :
maybePreviousWithMethod?.HasLeadingTrivia ?? false?
res.WithLeadingTrivia(maybePreviousWithMethod.GetLeadingTrivia()) : res;
return(res);
}
private MemberDeclarationSyntax MockVirtualMethod()
{
var parameters = F.SeparatedList(Symbol.Parameters.Select(ps => TypesForSymbols.AsParameterSyntax(ps)));
if (ArglistParameterName != null && TypesForSymbols.RuntimeArgumentHandle() != null)
{
parameters = parameters.Add(F.Parameter(F.Identifier(ArglistParameterName)).WithType(TypesForSymbols.RuntimeArgumentHandle()));
}
var method = F.MethodDeclaration(ReturnTypeWithoutReadonly, F.Identifier(MemberMockName))
.WithModifiers(F.TokenList(F.Token(SyntaxKind.ProtectedKeyword), F.Token(SyntaxKind.VirtualKeyword)))
.WithParameterList(F.ParameterList(parameters))
.WithBody(F.Block(ThrowMockMissingStatement("VirtualMethod")));
if (Symbol.TypeParameters.Any())
{
method = method.WithTypeParameterList(TypeParameterList());
var constraints = TypesForSymbols.AsConstraintClauses(Symbol.TypeParameters);
if (constraints.Any())
{
method = method.AddConstraintClauses(constraints);
}
}
return(method);
}
private ClassDeclarationSyntax GetClassForConstLocatorInInfo(WebLocatorInfo locatorInfo)
{
var infoMembers = new List <MemberDeclarationSyntax>();
var infoMembersList = new List <(string type, string fName, ExpressionSyntax expr)>
{
(nameof(WebLocatorType), nameof(locatorInfo.LocatorType), GetESForValue(locatorInfo.LocatorType)),
("string", nameof(locatorInfo.LocatorValue), GetESForValue(locatorInfo.LocatorValue)),
("bool", nameof(locatorInfo.IsRelative), GetESForValue(locatorInfo.IsRelative))
};
foreach (var infoMemberItem in infoMembersList)
{
var fd = SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName(infoMemberItem.type))
.AddVariables(SF.VariableDeclarator(SF.Identifier(infoMemberItem.fName))
.WithInitializer(SF.EqualsValueClause(infoMemberItem.expr))
)
)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.ConstKeyword));
infoMembers.Add(fd);
}
var infoCD = SF.ClassDeclaration(LocatorStaticClassName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddMembers(infoMembers.ToArray());
return(infoCD);
}
public static ConstructorDeclarationSyntax MakeConstructor(string className, IEnumerable <Field> fields)
{
var constructorParameters =
SF.ParameterList(
SF.SeparatedList(
fields.Select(field =>
SF.Parameter(SF.Identifier(field.Name))
.WithType(field.Type))));
var constructorBodyStatements =
fields.Select(
field =>
SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.ThisExpression(),
SF.IdentifierName(field.Name)
),
SF.IdentifierName(field.Name))));
return
(SF.ConstructorDeclaration(className)
.WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) }))
.WithParameterList(constructorParameters)
.WithBody(SF.Block(constructorBodyStatements)));
}
private ClassDeclarationSyntax GetClassForLocatorInInfo(WebLocatorInfo locatorInfo)
{
var infoMembers = new List <MemberDeclarationSyntax>();
var infoMembersList = new List <(string type, string fName, string value)>
{
(nameof(WebLocatorType), nameof(locatorInfo.LocatorType), $"{nameof(WebLocatorType)}.{locatorInfo.LocatorType}"),
("string", nameof(locatorInfo.LocatorValue), locatorInfo.LocatorValue),
("bool", nameof(locatorInfo.IsRelative), $"{locatorInfo.IsRelative}"),
};
foreach (var infoMemberItem in infoMembersList)
{
var docComment = GetDocCommentWithText(infoMemberItem.value);
var fd = SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName(infoMemberItem.type))
.AddVariables(SF.VariableDeclarator(SF.Identifier(infoMemberItem.fName))
)
)
.AddModifiers(
SF.Token(SF.TriviaList(), SyntaxKind.PublicKeyword, SF.TriviaList())
.WithLeadingTrivia(SF.Trivia(docComment))
);
infoMembers.Add(fd);
}
var infoCD = SF.ClassDeclaration(LocatorClassName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddMembers(infoMembers.ToArray());
return(infoCD);
}
public CompilationUnitSyntax StubInterface(CompilationUnitSyntax cu, InterfaceDeclarationSyntax interfaceDclr,
SemanticModel semanticModel)
{
INamedTypeSymbol interfaceType = semanticModel.GetDeclaredSymbol(interfaceDclr);
NamespaceDeclarationSyntax namespaceNode = GetNamespaceNode(interfaceDclr);
string interfaceName = interfaceType.GetGenericName();
string stubName = NamingUtils.GetStubName(interfaceName);
ClassDeclarationSyntax classDclr = SF.ClassDeclaration(SF.Identifier(stubName))
.AddModifiers(SF.Token(RoslynUtils.GetVisibilityKeyword(interfaceType)))
.WithBaseList(RoslynUtils.BaseList(interfaceName))
.AddAttributeLists(AttributeListList(Attribute("CompilerGenerated")).ToArray());
classDclr = RoslynUtils.CopyGenericConstraints(interfaceType, classDclr);
classDclr = AddStubContainerField(classDclr, stubName);
classDclr = StubProperties(interfaceType, classDclr);
classDclr = StubMethods(interfaceType, classDclr);
string fullNameSpace = semanticModel.GetDeclaredSymbol(namespaceNode).ToString();
NamespaceDeclarationSyntax namespaceDclr = SF.NamespaceDeclaration(SF.IdentifierName(fullNameSpace))
.WithUsings(namespaceNode.Usings);
namespaceDclr = namespaceDclr.AddMembers(classDclr);
cu = cu.AddMembers(namespaceDclr);
return(cu);
}
private static ParameterSyntax CreateFileSystemParameterDeclaration()
{
return(SF.Parameter(SF.Identifier("fileSystem"))
.WithType(CreateFileSystemType())
.WithAdditionalAnnotations(Formatter.Annotation, Simplifier.SpecialTypeAnnotation)
.NormalizeWhitespace());
}
private MethodDeclarationSyntax GetGetInstanceMethod(string className)
{
var comment = GetDocCommentWithText("Get new element instance");
var md = SF.MethodDeclaration(
SF.IdentifierName(className),
SF.Identifier("GetInstance")
)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(comment)), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("parentElement"))
.WithType(SF.IdentifierName(nameof(CombinedWebElementInfo)))
)
.WithExpressionBody(
SF.ArrowExpressionClause(
SF.ObjectCreationExpression(SF.IdentifierName(className))
.WithInitializer(
SF.InitializerExpression(
SyntaxKind.ObjectInitializerExpression
)
.AddExpressions(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(nameof(WebElementInfo.Parent)), SF.IdentifierName("parentElement"))
)
)
)
)
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken));
return(md);
}
private CasePatternSwitchLabelSyntax WrapInCasePatternSwitchLabelSyntax(VBSyntax.SelectBlockSyntax node, ExpressionSyntax cSharpSyntaxNode, bool treatAsBoolean = false)
{
var typeInfo = _semanticModel.GetTypeInfo(node.SelectStatement.Expression);
DeclarationPatternSyntax patternMatch;
if (typeInfo.ConvertedType.SpecialType == SpecialType.System_Boolean || treatAsBoolean)
{
patternMatch = SyntaxFactory.DeclarationPattern(
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)),
SyntaxFactory.DiscardDesignation());
}
else
{
var varName = CommonConversions.ConvertIdentifier(SyntaxFactory.Identifier(GetUniqueVariableNameInScope(node, "case"))).ValueText;
patternMatch = SyntaxFactory.DeclarationPattern(
SyntaxFactory.ParseTypeName("var"), SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(varName)));
cSharpSyntaxNode = SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, SyntaxFactory.IdentifierName(varName), cSharpSyntaxNode);
}
var casePatternSwitchLabelSyntax = SyntaxFactory.CasePatternSwitchLabel(patternMatch,
SyntaxFactory.WhenClause(cSharpSyntaxNode), SyntaxFactory.Token(SyntaxKind.ColonToken));
return(casePatternSwitchLabelSyntax);
}
//*/
//*
public static NameSyntax OptionalOf(TypeSyntax type)
{
return
(SF.GenericName(
SF.Identifier(nameof(Option)),
SF.TypeArgumentList(SF.SingletonSeparatedList(type))));
}
public static ParameterListSyntax AsParameterList(this IEnumerable <IParameterSymbol> parameters, MocklisTypesForSymbols typesForSymbols)
{
var args = parameters.Select(p =>
{
var syntax = F.Parameter(F.Identifier(p.Name)).WithType(typesForSymbols.ParseTypeName(p.Type, p.NullableOrOblivious()));
switch (p.RefKind)
{
case RefKind.In:
{
syntax = syntax.WithModifiers(F.TokenList(F.Token(SyntaxKind.InKeyword)));
break;
}
case RefKind.Out:
{
syntax = syntax.WithModifiers(F.TokenList(F.Token(SyntaxKind.OutKeyword)));
break;
}
case RefKind.Ref:
{
syntax = syntax.WithModifiers(F.TokenList(F.Token(SyntaxKind.RefKeyword)));
break;
}
}
return(syntax);
});
return(F.ParameterList(F.SeparatedList(args)));
}
private static string CreateClass_ColorNames(List <ColorEntity> entities, ProgressBar progress)
{
string classDeclaration;
using (var child = progress.Spawn(entities.Count, "enum items added", childOptions))
{
var members = entities.Select((entity, index) =>
{
//double prog = (double)index / entities.Count / STEPS;
//progress.Report(PROGRESS_STEP * lastStep + prog);
child.Tick();
// Console.WriteLine($"Converted {index} of {entities.Count} entities!");
return(Syntax.EnumMemberDeclaration(identifier:
Syntax.Identifier(entity.Name.SanitizeEnum())));
});
// TODO
// Console.WriteLine("Declaring enum!");
var declaration = Syntax.EnumDeclaration(
new SyntaxList <AttributeListSyntax>(),
identifier: Syntax.Identifier("ColorNames"),
modifiers: Syntax.TokenList(Syntax.Token(SyntaxKind.PublicKeyword)),
baseList: null,
members: Syntax.SeparatedList(members))
.NormalizeWhitespace();
classDeclaration = declaration.ToFullString();
}
return(classDeclaration);
}
public static NameSyntax IEquatableOf(TypeSyntax typeSyntax)
{
return(SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.GenericName(
SF.Identifier(nameof(IEquatable <int>)),
SF.TypeArgumentList(SF.SingletonSeparatedList(typeSyntax)))));
}
private MemberDeclarationSyntax MockGetVirtualMethod()
{
return(F.MethodDeclaration(ValueTypeSyntax, F.Identifier(MemberMockName))
.WithModifiers(F.TokenList(F.Token(SyntaxKind.ProtectedKeyword), F.Token(SyntaxKind.VirtualKeyword)))
.WithParameterList(F.ParameterList(F.SeparatedList(Symbol.Parameters.Select(a =>
F.Parameter(F.Identifier(a.Name)).WithType(TypesForSymbols.ParseTypeName(a.Type, a.NullableOrOblivious()))))))
.WithBody(F.Block(ThrowMockMissingStatement("VirtualIndexerGet"))));
}
public FieldDeclarationSyntax ToFieldDeclaration()
{
if (canonicalName.value != name.name.value)
{
Console.WriteLine($"Warning!!! '{canonicalName.value}' != '{name.name.value}';");
}
if (annotations.Count != 0)
{
Console.WriteLine($"Warning!!! Annotations!;");
}
var declaratorSyntax = SF.VariableDeclarator(SF.Identifier(name.name.value));
if (initializer.TryGetValue(out var initializerExpression))
{
declaratorSyntax = declaratorSyntax.WithInitializer(
// todo: I think this might not work ... a lot!
SF.EqualsValueClause(initializerExpression.ToLiteralExpressionSyntax()));
}
var fieldDeclaration = SF.FieldDeclaration(
SF.VariableDeclaration(type.ToTypeSyntax())
.WithVariables(SF.SingletonSeparatedList <VariableDeclaratorSyntax>(declaratorSyntax)));
if (flags.HasFlag(Flag.isConst))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ConstKeyword)));
}
if (flags.HasFlag(Flag.isFinal))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
if (flags.HasFlag(Flag.isStatic))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.StaticKeyword)));
}
if (flags.HasFlag(Flag.isCovariant))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.isGenericCovariantImpl))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.hasImplicitSetter))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.hasImplicitGetter))
{
throw new NotImplementedException();
}
return(fieldDeclaration);
}
/// <summary>
/// Returns syntax for the deserializer method.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="fields">The fields.</param>
/// <returns>Syntax for the deserializer method.</returns>
private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields)
{
Expression <Action> deserializeInner =
() => SerializationManager.DeserializeInner(default(Type), default(IDeserializationContext));
var contextParameter = SF.IdentifierName("context");
var resultDeclaration =
SF.LocalDeclarationStatement(
SF.VariableDeclaration(type.GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("result")
.WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type)))));
var resultVariable = SF.IdentifierName("result");
var body = new List <StatementSyntax> {
resultDeclaration
};
// Value types cannot be referenced, only copied, so there is no need to box & record instances of value types.
if (!type.GetTypeInfo().IsValueType)
{
// Record the result for cyclic deserialization.
Expression <Action <IDeserializationContext> > recordObject = ctx => ctx.RecordObject(default(object));
var currentSerializationContext = contextParameter;
body.Add(
SF.ExpressionStatement(
recordObject.Invoke(currentSerializationContext)
.AddArgumentListArguments(SF.Argument(resultVariable))));
}
// Deserialize all fields.
foreach (var field in fields)
{
var deserialized =
deserializeInner.Invoke()
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(field.Type)),
SF.Argument(contextParameter));
body.Add(
SF.ExpressionStatement(
field.GetSetter(
resultVariable,
SF.CastExpression(field.Type, deserialized))));
}
body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), resultVariable)));
return
(SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()),
SF.Parameter(SF.Identifier("context")).WithType(typeof(IDeserializationContext).GetTypeSyntax()))
.AddBodyStatements(body.ToArray())
.AddAttributeLists(
SF.AttributeList()
.AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax()))));
}
/// <summary>
/// Generates syntax for an invoke method.
/// </summary>
/// <param name="grainType">
/// The grain type.
/// </param>
/// <param name="invokeMethod">
/// The invoke method to generate.
/// </param>
/// <returns>
/// Syntax for an invoke method.
/// </returns>
private static MethodDeclarationSyntax GenerateInvokeMethod(Type grainType, MethodInfo invokeMethod)
{
var methodDeclaration = invokeMethod.GetDeclarationSyntax();
var parameters = invokeMethod.GetParameters();
var grainArgument = parameters[0].Name.ToIdentifierName();
var interfaceIdArgument = parameters[1].Name.ToIdentifierName();
var methodIdArgument = parameters[2].Name.ToIdentifierName();
var argumentsArgument = parameters[3].Name.ToIdentifierName();
var interfaceCases = CodeGeneratorCommon.GenerateGrainInterfaceAndMethodSwitch(
grainType,
methodIdArgument,
methodType => GenerateInvokeForMethod(grainType, grainArgument, methodType, argumentsArgument));
// Generate the default case, which will throw a NotImplementedException.
var errorMessage = SF.BinaryExpression(
SyntaxKind.AddExpression,
"interfaceId=".GetLiteralExpression(),
interfaceIdArgument);
var throwStatement =
SF.ThrowStatement(
SF.ObjectCreationExpression(typeof(NotImplementedException).GetTypeSyntax())
.AddArgumentListArguments(SF.Argument(errorMessage)));
var defaultCase = SF.SwitchSection().AddLabels(SF.DefaultSwitchLabel()).AddStatements(throwStatement);
var interfaceIdSwitch =
SF.SwitchStatement(interfaceIdArgument).AddSections(interfaceCases.ToArray()).AddSections(defaultCase);
// If the provided grain is null, throw an argument exception.
var argumentNullException =
SF.ObjectCreationExpression(typeof(ArgumentNullException).GetTypeSyntax())
.AddArgumentListArguments(SF.Argument(parameters[0].Name.GetLiteralExpression()));
var grainArgumentCheck =
SF.IfStatement(
SF.BinaryExpression(
SyntaxKind.EqualsExpression,
grainArgument,
SF.LiteralExpression(SyntaxKind.NullLiteralExpression)),
SF.ThrowStatement(argumentNullException));
// Wrap everything in a try-catch block.
var faulted = (Expression <Func <Task <object> > >)(() => TaskUtility.Faulted(null));
const string Exception = "exception";
var exception = SF.Identifier(Exception);
var body =
SF.TryStatement()
.AddBlockStatements(grainArgumentCheck, interfaceIdSwitch)
.AddCatches(
SF.CatchClause()
.WithDeclaration(
SF.CatchDeclaration(typeof(Exception).GetTypeSyntax()).WithIdentifier(exception))
.AddBlockStatements(
SF.ReturnStatement(
faulted.Invoke().AddArgumentListArguments(SF.Argument(SF.IdentifierName(Exception))))));
return(methodDeclaration.AddBodyStatements(body));
}
private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields)
{
Expression <Action> deserializeInner =
() => SerializationManager.DeserializeInner(default(Type), default(BinaryTokenStreamReader));
var streamParameter = SF.IdentifierName("stream");
var resultDeclaration =
SF.LocalDeclarationStatement(
SF.VariableDeclaration(type.GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("result")
.WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type)))));
var resultVariable = SF.IdentifierName("result");
var boxedResultVariable = resultVariable;
var body = new List <StatementSyntax> {
resultDeclaration
};
if (type.IsValueType)
{
// For value types, we need to box the result for reflection-based setters to work.
body.Add(SF.LocalDeclarationStatement(
SF.VariableDeclaration(typeof(object).GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("boxedResult").WithInitializer(SF.EqualsValueClause(resultVariable)))));
boxedResultVariable = SF.IdentifierName("boxedResult");
}
// Deserialize all fields.
foreach (var field in fields)
{
var deserialized =
deserializeInner.Invoke()
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(field.Type)),
SF.Argument(streamParameter));
body.Add(
SF.ExpressionStatement(
field.GetSetter(
resultVariable,
SF.CastExpression(field.Type, deserialized),
boxedResultVariable)));
}
body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), boxedResultVariable)));
return
(SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()),
SF.Parameter(SF.Identifier("stream")).WithType(typeof(BinaryTokenStreamReader).GetTypeSyntax()))
.AddBodyStatements(body.ToArray())
.AddAttributeLists(
SF.AttributeList()
.AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax()))));
}
private SyntaxTree CreateSyntaxTree()
{
var compilationUnit = SF
.CompilationUnit()
.AddUsings
(
SF.UsingDirective
(SF.ParseName("System"))
);
var ns = SF
.NamespaceDeclaration(SF.IdentifierName("SynTreeFred"));
var cls = SF
.ClassDeclaration("Henry")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword));
// How to define base class and interfaces, with/without generics
//
//cls = cls.AddBaseListTypes(
// SF.SimpleBaseType(SF.ParseTypeName("Object")),
// SF.SimpleBaseType(SF.ParseTypeName("IEnumerable<string>")));
var inti = SF
.VariableDeclaration(SF.ParseTypeName("int"))
.AddVariables
(
SF.VariableDeclarator
(
SF.Identifier("i"),
null,
SF.EqualsValueClause
(
SF.LiteralExpression
(
SyntaxKind.NumericLiteralExpression,
SF.Literal(12)
)
)
)
);
var field = SF.FieldDeclaration(inti)
.AddModifiers(SF.Token(SyntaxKind.PrivateKeyword));
var syntax = SF.ParseStatement("return ++i;");
var methodDeclaration = SF
.MethodDeclaration(SF.ParseTypeName("int"), "GetNextInt")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.WithBody(SF.Block(syntax));
cls = cls.AddMembers(field, methodDeclaration);
ns = ns.AddMembers(cls);
compilationUnit = compilationUnit.AddMembers(ns);
return(compilationUnit.SyntaxTree);
}
public PropertyDeclarationSyntax GenerateListProperty(string propertyName, PrimitiveType type)
{
return(SF.PropertyDeclaration(
SF.GenericName(SF.Identifier("List"))
.WithTypeArgumentList(
SF.TypeArgumentList(
SF.SingletonSeparatedList <TypeSyntax>(
SF.PredefinedType(SF.Token(FromPrimitive(type)))))),
SF.Identifier(propertyName)));
}
public PropertyDeclarationSyntax GenerateListProperty(string propertyName, string typeName)
{
return(SF.PropertyDeclaration(
SF.GenericName(SF.Identifier("List"))
.WithTypeArgumentList(
SF.TypeArgumentList(
SF.SingletonSeparatedList <TypeSyntax>(
SF.IdentifierName(typeName)))),
SF.Identifier(propertyName)));
}
private MemberDeclarationSyntax MockSetVirtualMethod()
{
return(F.MethodDeclaration(F.PredefinedType(F.Token(SyntaxKind.VoidKeyword)), F.Identifier(MemberMockName))
.WithParameterList(F.ParameterList(F.SeparatedList(new[]
{
F.Parameter(F.Identifier("value")).WithType(ValueTypeSyntax)
})))
.WithModifiers(F.TokenList(F.Token(SyntaxKind.ProtectedKeyword), F.Token(SyntaxKind.VirtualKeyword)))
.WithBody(F.Block(ThrowMockMissingStatement("VirtualPropertySet"))));
}
public WebInfoGenerationData GetClassForWebElement(WebElementInfo info)
{
var className = GetClassNameFromElementName(info.Name);
var propName = className.Substring(1);
var constInfoCD = GetClassForConstInfo(info);
var baseClassName = info.GetType().Name;
var docComment = GetDocCommentWithText(info.Description);
var infoComment = GetDocCommentWithText("Information about element");
var infoProperty = SF.PropertyDeclaration(
SF.ParseTypeName($"{InfoStaticClassName}.{InfoClassName}"),
SF.Identifier(InfoClassName)
)
.WithAccessorList(
SF.AccessorList(
SF.List(
new List <AccessorDeclarationSyntax>
{
SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)),
SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken))
}
)
)
.WithOpenBraceToken(SF.Token(SyntaxKind.OpenBraceToken))
.WithCloseBraceToken(SF.Token(SyntaxKind.CloseBraceToken))
)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(infoComment)));
var getInstMd = GetGetInstanceMethod(className);
var cd = SF.ClassDeclaration(className)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(docComment)))
.AddBaseListTypes(SF.SimpleBaseType(SF.IdentifierName(baseClassName)))
.AddMembers(infoProperty, getInstMd, constInfoCD);
var genData = new WebInfoGenerationData
{
ClassName = className,
PropertyName = propName,
ClassSyntax = cd,
Element = info
};
FillWithChildrenElementsProperties(genData, out List <WebInfoGenerationData> childrenGens);
AddCtor(genData, childrenGens);
FillWithChildrenElementsClasses(genData, childrenGens);
return(genData);
}
private static VariableDeclarationSyntax CreateVariableDeclaration(string variableName,
ExpressionSyntax variableValue)
{
var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variableName), null,
SyntaxFactory.EqualsValueClause(variableValue));
var declaration = SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax));
return(declaration);
}
public static NameSyntax IReadOnlyListOf(TypeSyntax elementType)
{
return(SF.QualifiedName(
SF.QualifiedName(
SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.IdentifierName(nameof(System.Collections))),
SF.IdentifierName(nameof(System.Collections.Generic))),
SF.GenericName(
SF.Identifier(nameof(IReadOnlyList <int>)),
SF.TypeArgumentList(SF.SingletonSeparatedList(elementType)))));
}
public static NameSyntax KeyValuePairOf(TypeSyntax keyType, TypeSyntax valueType)
{
return(SF.QualifiedName(
SF.QualifiedName(
SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.IdentifierName(nameof(System.Collections))),
SF.IdentifierName(nameof(System.Collections.Generic))),
SF.GenericName(
SF.Identifier(nameof(KeyValuePair <int, int>)),
SF.TypeArgumentList(JoinSyntaxNodes(SyntaxKind.CommaToken, keyType, valueType)))));
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
FieldDeclarationSyntax aField = SF.FieldDeclaration(
SF.VariableDeclaration(
SF.ParseTypeName(" string "),
SF.SeparatedList(new[] { SF.VariableDeclarator(SF.Identifier("bopin=\"Hi bopin\"")) })
))
.AddModifiers(SF.Token(SyntaxKind.StaticKeyword)); //SyntaxKind.PublicKeyword),
node = node.AddMembers(aField);
return(base.VisitClassDeclaration(node));
}
static SyntaxToken?ConvertModifier(SyntaxToken m, TokenContext context = SyntaxKindExtensions.TokenContext.Global)
{
VBasic.SyntaxKind vbSyntaxKind = VBasic.VisualBasicExtensions.Kind(m);
switch (vbSyntaxKind)
{
case VBasic.SyntaxKind.DateKeyword:
return(SyntaxFactory.Identifier("DateTime"));
}
var token = SyntaxKindExtensions.ConvertToken(vbSyntaxKind, context);
return(token == SyntaxKind.None ? null : new SyntaxToken?(SyntaxFactory.Token(token)));
}