public ExpressionSyntax AddExplicitConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeConversionKind conversionKind, bool addParenthesisIfNeeded = false, bool isConst = false, ITypeSymbol forceTargetType = null)
{
var typeInfo = ModelExtensions.GetTypeInfo(_semanticModel, vbNode);
var vbType = typeInfo.Type;
var vbConvertedType = forceTargetType ?? typeInfo.ConvertedType;
if (isConst && _expressionEvaluator.GetConstantOrNull(vbNode, vbConvertedType, csNode) is ExpressionSyntax constLiteral)
{
return(constLiteral);
}
switch (conversionKind)
{
case TypeConversionKind.Unknown:
case TypeConversionKind.Identity:
return(addParenthesisIfNeeded ? VbSyntaxNodeExtensions.ParenthesizeIfPrecedenceCouldChange(vbNode, csNode) : csNode);
case TypeConversionKind.DestructiveCast:
case TypeConversionKind.NonDestructiveCast:
return(CreateCast(csNode, vbConvertedType));
case TypeConversionKind.Conversion:
return(AddExplicitConvertTo(vbNode, csNode, vbType, vbConvertedType));;
case TypeConversionKind.NullableBool:
return(SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, csNode,
LiteralConversions.GetLiteralExpression(true)));
case TypeConversionKind.StringToCharArray:
var memberAccessExpressionSyntax = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, csNode, SyntaxFactory.IdentifierName(nameof(string.ToCharArray)));
return(SyntaxFactory.InvocationExpression(memberAccessExpressionSyntax,
SyntaxFactory.ArgumentList()));
default:
throw new ArgumentOutOfRangeException();
}
}
public bool TryConvertToNullOrEmptyCheck(VBSyntax.BinaryExpressionSyntax node, ExpressionSyntax lhs,
ExpressionSyntax rhs, out CSharpSyntaxNode visitBinaryExpression)
{
bool lhsEmpty = IsNothingOrEmpty(node.Left);
bool rhsEmpty = IsNothingOrEmpty(node.Right);
if (lhsEmpty || rhsEmpty)
{
var arg = lhsEmpty ? rhs : lhs;
var nullOrEmpty = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("string"),
SyntaxFactory.IdentifierName("IsNullOrEmpty")),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[]
{ SyntaxFactory.Argument(arg) })));
{
visitBinaryExpression = NegateIfNeeded(node, nullOrEmpty);
return(true);
}
}
visitBinaryExpression = null;
return(false);
}
private MemberDeclarationSyntax TypedMockProviderField()
{
return(F.FieldDeclaration(F.VariableDeclaration(TypesForSymbols.TypedMockProvider()).WithVariables(
F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(MockProviderName))
.WithInitializer(F.EqualsValueClause(F.ObjectCreationExpression(TypesForSymbols.TypedMockProvider())
.WithArgumentList(F.ArgumentList())))))
).WithModifiers(F.TokenList(F.Token(SyntaxKind.PrivateKeyword), F.Token(SyntaxKind.ReadOnlyKeyword))));
}
protected override ExpressionSyntax ExplicitInterfaceMemberMemberMockInstance()
{
return(F.InvocationExpression(F.GenericName(MemberMockName).WithTypeArgumentList(TypeArgumentList())).WithArgumentList(F.ArgumentList()));
}
public static InvocationExpressionSyntax OptionalGetValueOrDefault(ExpressionSyntax optionalOfTExpression, ExpressionSyntax defaultValue)
{
return(SF.InvocationExpression(
SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, optionalOfTExpression, SF.IdentifierName(nameof(Option <int> .ValueOr))),
SF.ArgumentList(SF.SingletonSeparatedList(SF.Argument(defaultValue)))));
}
/// <summary>
/// Create a new <see cref="ExpressionSyntax"/> that invokes the <see cref="method"/>.
/// </summary>
/// <param name="moduleType">The module type.</param>
/// <param name="method">The method to invoke.</param>
/// <returns>The <see cref="ExpressionSyntax"/>.</returns>
private ExpressionSyntax InvokeCommand(Type moduleType, MethodInfo method)
{
var moduleSyntaxType = S.ParseTypeName(moduleType.FullName.Replace('+', '.'));
var listSyntax = S.ArgumentList();
var constructor = moduleType.GetConstructors().FirstOrDefault();
if (constructor != null)
{
listSyntax = listSyntax.AddArguments(constructor.GetParameters().Select(p => S.Argument(GetValueFactory(p))).ToArray());
}
var moduleInstance = S.ObjectCreationExpression(moduleSyntaxType).WithArgumentList(listSyntax);
var contextProperty = moduleType
.GetProperties()
.FirstOrDefault(p => p.GetCustomAttributes <ModuleContextAttribute>().Any());
if (contextProperty != null)
{
var contextInstance = S.ObjectCreationExpression(ModuleContextType)
.WithInitializer(
S.InitializerExpression(
SyntaxKind.ObjectInitializerExpression,
S.SingletonSeparatedList <ExpressionSyntax>(
S.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
S.IdentifierName(nameof(ModuleContext.Context)),
S.IdentifierName(ArgumentContext)
))));
moduleInstance = moduleInstance.WithInitializer(
S.InitializerExpression(
SyntaxKind.ObjectInitializerExpression,
S.SingletonSeparatedList <ExpressionSyntax>(
S.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
S.IdentifierName(contextProperty.Name),
contextInstance
))));
}
ExpressionSyntax invoke = S.InvocationExpression(
S.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
moduleInstance,
S.IdentifierName(method.Name)
),
S.ArgumentList().AddArguments(method.GetParameters().Select(p => S.Argument(GetValueFactory(p))).ToArray())
);
if (method.ReturnType == typeof(Task) || method.ReturnType == typeof(ValueTask))
{
invoke = S.AwaitExpression(invoke);
}
else if (method.ReturnType != typeof(void))
{
throw new InvalidOperationException($"The return type {method.ReturnType.Name} is not supported.");
}
return(invoke);
}
IEnumerable <MemberDeclarationSyntax> CreateConstructors()
{
SyntaxToken typeName = Symbols.GetNameSyntaxToken(Type);
if (Type.Initializer != null)
{
yield return(SF.ConstructorDeclaration
(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(
Type.IsAbstract || Type.Initializer.IsProtected
? SyntaxKind.ProtectedKeyword
: SyntaxKind.PublicKeyword
)),
typeName,
Type.Initializer.GetParameterListSyntax(Namespaces, Symbols),
SF.ConstructorInitializer
(
SyntaxKind.BaseConstructorInitializer,
SF.ArgumentList(
SF.SeparatedList(new[]
{
SF.Argument(
SF.ObjectCreationExpression(
SF.Token(SyntaxKind.NewKeyword),
SF.ParseTypeName("DeputyProps"),
SF.ArgumentList(SF.SeparatedList(
new[] { GetBaseArgument() }
)),
null
)
)
})
)
),
SF.Block(),
null
));
}
yield return(SF.ConstructorDeclaration
(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(SyntaxKind.ProtectedKeyword)),
typeName,
SF.ParseParameterList("(ByRefValue reference)"),
SF.ConstructorInitializer
(
SyntaxKind.BaseConstructorInitializer,
SF.ParseArgumentList("(reference)")
),
SF.Block(),
null
));
// This constructor allows child classes to supply their own parameter lists. It is always protected.
yield return(SF.ConstructorDeclaration
(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(SyntaxKind.ProtectedKeyword)),
typeName,
SF.ParseParameterList("(DeputyProps props)"),
SF.ConstructorInitializer
(
SyntaxKind.BaseConstructorInitializer,
SF.ParseArgumentList("(props)")
),
SF.Block(),
null
));
ArgumentSyntax GetBaseArgument()
{
var deputyArguments = (Type.Initializer.Parameters ?? Enumerable.Empty <Parameter>())
.Select(p => Symbols.GetNameSyntaxToken(p))
.Select(i => SF.IdentifierName(i));
// In C#, arrays of reference types are covariant. Because of this, passing a string[]
// to a method that takes `params object[] args` will interperet the string array *as*
// args, rather than as args' first element. To workaround with, we remove the params
// keyword from DeputyBase's constructor, and always explicitly create an array of
// objects when calling it.
return(SF.Argument(
SF.ArrayCreationExpression(
SF.Token(SyntaxKind.NewKeyword),
SF.ArrayType(SF.ParseTypeName("object[]")),
SF.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SF.SeparatedList <ExpressionSyntax>(deputyArguments)
)
)
));
}
}
public ConstructorBuilder CallThis(IEnumerable <ExpressionBuilder> parameters)
=> new ConstructorBuilder(_modifiers, _name, _parameters,
SF.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer,
SF.ArgumentList(SF.SeparatedList(parameters.Select(p => SF.Argument(p.Build()))))),
_expr, _block);
public ExpressionBuilder Call(string method, IEnumerable <string> typeParameters, IEnumerable <ExpressionBuilder> expressions)
=> new ExpressionBuilder(SF.InvocationExpression(
SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, _expr,
SF.GenericName(method).WithTypeArgumentList(SF.TypeArgumentList(SF.SeparatedList(typeParameters.Select(tp => ParseType(tp)))))),
SF.ArgumentList(SF.SeparatedList(expressions.Select(e => SF.Argument(e.Build()))))));
public ExpressionBuilder Invoke(IEnumerable <ExpressionBuilder> expressions) => new ExpressionBuilder(SF.InvocationExpression(_expr, SF.ArgumentList(SF.SeparatedList(expressions.Select(e => SF.Argument(e.Build()))))));
public ExpressionBuilder Call(string method, IEnumerable <ExpressionBuilder> expressions)
=> new ExpressionBuilder(SF.InvocationExpression(SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, _expr, SF.IdentifierName(method)),
SF.ArgumentList(SF.SeparatedList(expressions.Select(e => SF.Argument(e.Build()))))));
private async Task <Document> Handle(Diagnostic diagnostic, CodeFixContext context)
{
var root = await context.Document
.GetSyntaxRootAsync(context.CancellationToken)
.ConfigureAwait(false);
if (root is null)
{
return(context.Document);
}
var semanticModel = await context.Document.GetSemanticModelAsync();
var targetNode = root.FindNode(diagnostic.Location.SourceSpan);
var methodNode = targetNode.FirstAncestorOrSelf <MethodDeclarationSyntax>();
if (methodNode is null)
{
return(context.Document);
}
var maybeMethod = semanticModel.GetDeclaredSymbol(methodNode);
if (!(maybeMethod is IMethodSymbol method) || method.Parameters.IsEmpty)
{
return(context.Document);
}
var inputParameter = method.Parameters.Last();
var outputType = method.ReturnType;
var descendantNodes = targetNode
.DescendantNodes()
.ToArray();
var returnStatement = descendantNodes
.OfType <ReturnStatementSyntax>()
.LastOrDefault();
var allAssignments = descendantNodes
.OfType <AssignmentExpressionSyntax>()
.ToArray();
var outputProperties = outputType
.GetAllPublicProperties()
.ToDictionary(o => o.Name, o => o.Type);
var assignmentProperties = allAssignments
.Select(o => o.Left)
.OfType <MemberAccessExpressionSyntax>()
.Select(o => o.Name.Identifier.Text)
.ToImmutableHashSet();
var missingProperties = outputProperties
.Where(o => !assignmentProperties.Contains(o.Key))
.ToArray();
if (returnStatement == null)
{
return(FillMethod());
}
return(AddMissingAssignments());
Document AddMissingAssignments()
{
var newAssignmentExpressions = missingProperties
.Select(property => SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName("output"),
SF.IdentifierName(property.Key)),
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(inputParameter.Name),
SF.IdentifierName(property.Key)))
))
.ToArray();
var newRoot = root.InsertNodesBefore(returnStatement, newAssignmentExpressions);
var newDocument = context.Document
.WithSyntaxRoot(newRoot);
return(newDocument);
}
Document FillMethod()
{
var outputVariable = SF.LocalDeclarationStatement(
SF.VariableDeclaration(SF.ParseTypeName("var"),
SF.SeparatedList(
new[]
{
SF.VariableDeclarator(
SF.Identifier("output"),
null,
SF.EqualsValueClause(
SF.ObjectCreationExpression(
SF.ParseTypeName(outputType.ToGlobalName()),
SF.ArgumentList(),
null)))
})));
var newAssignmentExpressions = missingProperties
.Select(property => SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName("output"),
SF.IdentifierName(property.Key)),
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(inputParameter.Name),
SF.IdentifierName(property.Key)))
))
.ToArray();
var returnOutputVariable = SF.ReturnStatement(
SF.IdentifierName("output"));
var statements =
new StatementSyntax[] { outputVariable }
.Concat(newAssignmentExpressions)
.Concat(new[] { returnOutputVariable });
var newRoot = root.ReplaceNode(methodNode, methodNode.WithBody(SF.Block(statements)));
var newDocument = context.Document
.WithSyntaxRoot(newRoot);
return(newDocument);
}
}
public static ArgumentListSyntax PrependArgument(this ArgumentListSyntax list, ArgumentSyntax argument)
{
return(SF.ArgumentList(SF.SingletonSeparatedList(argument))
.AddArguments(list.Arguments.ToArray()));
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedProperty = F.PropertyDeclaration(ValueWithReadonlyTypeSyntax, Symbol.Name)
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedProperty = mockedProperty
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(F.SeparatedList(new[] { F.Argument(F.IdentifierName("value")) })))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedProperty);
}
public static ArgumentListSyntax Arguments(params IdentifierNameSyntax[] args)
{
return(SF.ArgumentList(new SeparatedSyntaxList <ArgumentSyntax>().AddRange(args.AsEnumerable().Select(arg => SF.Argument(arg)))));
}
void Save(string packageOutputRoot, ISymbolMap symbols, Assembly assembly, string tarballFileName, string jsiiFileName)
{
if (assembly.Docs != null)
{
// TODO: Use Microsoft.Extensions.Logging instead of Console.Error.
Console.Error.WriteLine($"Warning: Ignoring documentation comment on assembly {assembly.Name}. Assembly-level documentation comments are not supported for .NET");
}
SaveProjectFile();
SaveAssemblyInfo(assembly.Name, assembly.Version, tarballFileName);
SaveDependencyAnchorFile();
foreach (Type type in assembly.Types?.Values ?? Enumerable.Empty <Type>())
{
SaveType(type);
}
void SaveProjectFile()
{
XElement project =
new XElement("Project",
new XAttribute("Sdk", "Microsoft.NET.Sdk"),
new XElement("PropertyGroup", assembly.GetMsBuildProperties()),
new XElement("ItemGroup",
new XElement("EmbeddedResource",
new XAttribute("Include", tarballFileName)
)
),
new XElement("ItemGroup",
new XElement("PackageReference",
new XAttribute("Include", "Amazon.JSII.Runtime"),
new XAttribute("Version", JsiiVersion.Version)
),
GetDependencies()
.Distinct()
.Select(d => new { Package = symbols.GetAssemblyName(d.Key), Version = d.Value.GetDecoratedVersion() })
.Select(d =>
new XElement("PackageReference",
new XAttribute("Include", d.Package),
new XAttribute("Version", d.Version)
)
)
)
);
if (!_fileSystem.Directory.Exists(packageOutputRoot))
{
_fileSystem.Directory.CreateDirectory(packageOutputRoot);
}
// Save to StringBuilder instead of directly to path, so that we can
// redirect the output through the filesystem shim. Project files are
// small, so this shouldn't be a memory hog.
StringBuilder builder = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
// Visual Studio omits the XML declaration when creating project files, so we do too.
OmitXmlDeclaration = true,
// Visual Studio indents project files (they are often edited by hand), so we do too.
Indent = true,
};
using (XmlWriter writer = XmlWriter.Create(builder, settings))
{
project.Save(writer);
}
string csProjPath = Path.Combine(packageOutputRoot, $"{assembly.GetNativePackageId()}.csproj");
_fileSystem.File.WriteAllText(csProjPath, builder.ToString());
IEnumerable <KeyValuePair <string, PackageVersion> > GetDependencies()
{
foreach (KeyValuePair <string, PackageVersion> dependency in GetDependenciesCore(assembly))
{
yield return(dependency);
}
IEnumerable <KeyValuePair <string, PackageVersion> > GetDependenciesCore(DependencyRoot root)
{
if (root.Dependencies == null)
{
yield break;
}
foreach (var kvp in root.Dependencies)
{
yield return(kvp);
foreach (KeyValuePair <string, PackageVersion> dependency in GetDependenciesCore(kvp.Value))
{
yield return(dependency);
}
}
}
}
}
void SaveDependencyAnchorFile()
{
string anchorNamespace = $"{assembly.GetNativeNamespace()}.Internal.DependencyResolution";
var syntaxTree = SF.SyntaxTree(
SF.CompilationUnit(
SF.List <ExternAliasDirectiveSyntax>(),
SF.List <UsingDirectiveSyntax>(),
SF.List <AttributeListSyntax>(),
SF.List <MemberDeclarationSyntax>(new[] {
SF.NamespaceDeclaration(
SF.IdentifierName(anchorNamespace),
SF.List <ExternAliasDirectiveSyntax>(),
SF.List <UsingDirectiveSyntax>(),
SF.List(new MemberDeclarationSyntax[] { GenerateDependencyAnchor() })
)
})
).NormalizeWhitespace(elasticTrivia: true)
);
string directory = GetNamespaceDirectory(packageOutputRoot, @anchorNamespace);
SaveSyntaxTree(directory, "Anchor.cs", syntaxTree);
ClassDeclarationSyntax GenerateDependencyAnchor()
{
return(SF.ClassDeclaration(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)),
SF.Identifier("Anchor"),
null,
null,
SF.List <TypeParameterConstraintClauseSyntax>(),
SF.List(new MemberDeclarationSyntax[] {
SF.ConstructorDeclaration(
SF.List <AttributeListSyntax>(),
SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)),
SF.Identifier("Anchor"),
SF.ParameterList(SF.SeparatedList <ParameterSyntax>()),
null,
SF.Block(SF.List(GenerateAnchorReferences())),
null
)
})
));
IEnumerable <StatementSyntax> GenerateAnchorReferences()
{
return(assembly.Dependencies?.Keys
.Select(k => assembly.GetNativeNamespace(k))
.Select(n => $"{n}.Internal.DependencyResolution.Anchor")
.Select(t => SF.ExpressionStatement(SF.ObjectCreationExpression(
SF.Token(SyntaxKind.NewKeyword),
SF.ParseTypeName(t),
SF.ArgumentList(SF.SeparatedList <ArgumentSyntax>()),
null
))) ?? Enumerable.Empty <StatementSyntax>());
}
}
}
void SaveAssemblyInfo(string name, string version, string tarball)
{
SyntaxTree assemblyInfo = SF.SyntaxTree(
SF.CompilationUnit(
SF.List <ExternAliasDirectiveSyntax>(),
SF.List(new[] {
SF.UsingDirective(SF.ParseName("Amazon.JSII.Runtime.Deputy"))
}),
SF.List(new[] {
SF.AttributeList(
SF.AttributeTargetSpecifier(
SF.Identifier("assembly"),
SF.Token(SyntaxKind.ColonToken)
),
SF.SeparatedList(new[] {
SF.Attribute(
SF.ParseName("JsiiAssembly"),
SF.ParseAttributeArgumentList($"({SF.Literal(name)}, {SF.Literal(version)}, {SF.Literal(tarball)})")
)
})
)
}),
SF.List <MemberDeclarationSyntax>()
).NormalizeWhitespace(elasticTrivia: true)
);
string assemblyInfoPath = Path.Combine(packageOutputRoot, "AssemblyInfo.cs");
_fileSystem.File.WriteAllText(assemblyInfoPath, assemblyInfo.ToString());
}
void SaveType(Type type)
{
string @namespace = symbols.GetNamespace(type);
string directory = GetNamespaceDirectory(packageOutputRoot, @namespace);
switch (type.Kind)
{
case TypeKind.Class:
{
var classType = (ClassType)type;
if (classType.IsAbstract)
{
SaveTypeFile($"{symbols.GetAbstractClassProxyName(classType)}.cs",
new AbstractClassProxyGenerator(assembly.Name, classType, symbols).CreateSyntaxTree());
}
SaveTypeFile($"{symbols.GetName(type)}.cs",
new ClassGenerator(assembly.Name, classType, symbols).CreateSyntaxTree());
return;
}
case TypeKind.Enum:
{
SaveTypeFile($"{symbols.GetName(type)}.cs",
new EnumGenerator(assembly.Name, (EnumType)type, symbols).CreateSyntaxTree());
return;
}
case TypeKind.Interface:
{
InterfaceType interfaceType = (InterfaceType)type;
SaveTypeFile($"{symbols.GetName(interfaceType)}.cs",
new InterfaceGenerator(assembly.Name, interfaceType, symbols).CreateSyntaxTree());
SaveTypeFile($"{symbols.GetInterfaceProxyName(interfaceType)}.cs",
new InterfaceProxyGenerator(assembly.Name, interfaceType, symbols).CreateSyntaxTree());
if (interfaceType.IsDataType)
{
SaveTypeFile($"{symbols.GetInterfaceDefaultName(interfaceType)}.cs",
new InterfaceDefaultGenerator(assembly.Name, interfaceType, symbols)
.CreateSyntaxTree());
}
return;
}
default:
{
throw new ArgumentException($"Unkown type kind: {type.Kind}", nameof(type));
}
}
void SaveTypeFile(string filename, SyntaxTree syntaxTree)
{
SaveSyntaxTree(directory, filename, syntaxTree);
}
}
void SaveSyntaxTree(string directory, string filename, SyntaxTree syntaxTree)
{
if (!_fileSystem.Directory.Exists(directory))
{
_fileSystem.Directory.CreateDirectory(directory);
}
_fileSystem.File.WriteAllText(
Path.Combine(directory, filename),
syntaxTree.ToString()
);
}
}
public static ObjectCreationExpressionSyntax ObjectCreationWitoutArgs(INamedTypeSymbol sym)
{
return(SF.ObjectCreationExpression(SF.ParseTypeName(sym.ToString()), SF.ArgumentList(), default));
}
public ClassDeclarationSyntax GenerateHelper()
{
if (!HasImports)
{
return(null);
}
var xAttributeList = SyntaxFactory.FieldDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.PrivateKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
CommonConversions.CreateVariableDeclarationAndAssignment(
"namespaceAttributes", SyntaxFactory.InitializerExpression(
CSSyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
from x in _xNamespaceFields
let fieldIdentifierName = SyntaxFactory.IdentifierName(x.Declaration.Variables.Single().Identifier)
let namespaceNameExpression = SyntaxFactory.MemberAccessExpression(CSSyntaxKind.SimpleMemberAccessExpression, fieldIdentifierName, SyntaxFactory.IdentifierName("NamespaceName"))
let attributeNameExpression = fieldIdentifierName.IsEquivalentTo(DefaultIdentifierName) ? CommonConversions.Literal("xmlns") : BuildXmlnsAttributeName(fieldIdentifierName)
let arguments = SyntaxFactory.Argument(attributeNameExpression).Yield().Concat(SyntaxFactory.Argument(namespaceNameExpression))
select SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("XAttribute")).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))))),
SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName("XAttribute"), SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression()))))));
var boilerplate = SyntaxFactory.ParseStatement(@"
TContainer Apply<TContainer>(TContainer x) where TContainer : XContainer
{
foreach (var d in x.Descendants()) {
foreach (var n in namespaceAttributes) {
var a = d.Attribute(n.Name);
if (a != null && a.Value == n.Value) {
a.Remove();
}
}
}
x.Add(namespaceAttributes);
return x;
}") as LocalFunctionStatementSyntax;
var applyMethod = SyntaxFactory.MethodDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
boilerplate.ReturnType,
null,
boilerplate.Identifier,
boilerplate.TypeParameterList,
boilerplate.ParameterList,
boilerplate.ConstraintClauses,
boilerplate.Body,
boilerplate.ExpressionBody);
return(SyntaxFactory.ClassDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
HelperClassUniqueIdentifierName.Identifier,
null, null,
SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(),
SyntaxFactory.List(_xNamespaceFields.Concat <MemberDeclarationSyntax>(xAttributeList).Concat(applyMethod))
));
}
public static InvocationExpressionSyntax InvocationExpression(IdentifierNameSyntax source, IdentifierNameSyntax member, params ArgumentSyntax[] args)
{
return(SF.InvocationExpression(SimpleMemberAccess(source, member), SF.ArgumentList().AddArguments(args)));
}
private void AddCtor(WebInfoGenerationData genData, List <WebInfoGenerationData> childrenGens)
{
var statements = new List <StatementSyntax>();
var infoInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(InfoClassName),
SF.ObjectCreationExpression(SF.ParseTypeName($"{InfoStaticClassName}.{InfoClassName}"))
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(infoInit);
var locatorInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(LocatorClassName),
SF.ObjectCreationExpression(SF.IdentifierName(nameof(WebLocatorInfo)))
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(locatorInit);
var locatorProps = new List <string>
{
nameof(WebLocatorInfo.LocatorType),
nameof(WebLocatorInfo.LocatorValue),
nameof(WebLocatorInfo.IsRelative)
};
foreach (var locatorProp in locatorProps)
{
var st = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(LocatorClassName),
SF.IdentifierName(locatorProp)
),
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(InfoStaticClassName),
SF.IdentifierName(LocatorStaticClassName)
),
SF.IdentifierName(locatorProp)
)
)
);
statements.Add(st);
}
if (childrenGens?.Count > 0)
{
var elsInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(nameof(CombinedWebElementInfo.Elements)),
SF.ObjectCreationExpression(
SF.GenericName(SF.Identifier("List"))
.WithTypeArgumentList(SF.TypeArgumentList(SF.SingletonSeparatedList <TypeSyntax>(SF.IdentifierName(nameof(WebElementInfo)))))
)
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(elsInit);
foreach (var childGen in childrenGens)
{
var propInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(childGen.PropertyName),
SF.ObjectCreationExpression(SF.IdentifierName(childGen.ClassName))
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(propInit);
var parentSt = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(childGen.PropertyName),
SF.IdentifierName(nameof(WebElementInfo.Parent))
),
SF.ThisExpression()
)
);
statements.Add(parentSt);
var elsAddSt = SF.ExpressionStatement(
SF.InvocationExpression(
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(nameof(CombinedWebElementInfo.Elements)),
SF.IdentifierName("Add")
)
).WithArgumentList(
SF.ArgumentList(
SF.SingletonSeparatedList(SF.Argument(SF.IdentifierName(childGen.PropertyName)))
)
)
);
statements.Add(elsAddSt);
}
}
var summary = GetDocCommentWithText(genData.Element.Description);
var ctor = SF.ConstructorDeclaration(SF.Identifier(genData.ClassName))
.WithBody(SF.Block(statements))
.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(summary))));
var cd = genData.ClassSyntax.AddMembers(ctor);
genData.ClassSyntax = cd;
}
public static InvocationExpressionSyntax InvocationExpression0(IdentifierNameSyntax source, IdentifierNameSyntax member)
{
return(SF.InvocationExpression(SimpleMemberAccess(source, member), SF.ArgumentList()));
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedIndexer = F.IndexerDeclaration(ValueWithReadonlyTypeSyntax)
.WithParameterList(F.BracketedParameterList(F.SeparatedList(Symbol.Parameters.Select(a =>
F.Parameter(F.Identifier(a.Name)).WithType(TypesForSymbols.ParseTypeName(a.Type, a.NullableOrOblivious()))))))
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))))));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedIndexer = mockedIndexer
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))));
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName))
.WithArgumentList(F.ArgumentList(argumentList))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))))
.Add(F.Argument(F.IdentifierName("value")));
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(argumentList))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedIndexer);
}
private static ArgumentListSyntax CreateArgList(params ExpressionSyntax[] copyArgs)
{
return(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(copyArgs.Select(SyntaxFactory.Argument))));
}