private static BlockSyntax GenerateBlock(IMethodSymbol accessor)
{
return(SyntaxFactory.Block(
StatementGenerator.GenerateStatements(CodeGenerationMethodInfo.GetStatements(accessor))));
}
// For the purposes of SemanticModel, it is convenient to have an AliasSymbol for the "global" namespace that "global::" binds
// to. This alias symbol is returned only when binding "global::" (special case code).
internal static AliasSymbol CreateGlobalNamespaceAlias(NamespaceSymbol globalNamespace, Binder globalNamespaceBinder)
{
SyntaxToken aliasName = SyntaxFactory.Identifier(SyntaxFactory.TriviaList(), SyntaxKind.GlobalKeyword, "global", "global", SyntaxFactory.TriviaList());
return(new AliasSymbol(globalNamespaceBinder, globalNamespace, aliasName, ImmutableArray <Location> .Empty));
}
public InterpolatedStringExpressionSyntax ToInterpolatedString()
{
var sb = new StringBuilder();
sb.Append('$');
if (!ContainsRegular)
{
sb.Append('@');
}
sb.Append('"');
for (int i = 0; i < Expressions.Length; i++)
{
SyntaxKind kind = Expressions[i].Kind();
if (kind == SyntaxKind.StringLiteralExpression)
{
var literal = (LiteralExpressionSyntax)Expressions[i];
if (ContainsRegular &&
ContainsVerbatimLiteral &&
literal.IsVerbatimStringLiteral())
{
string s = literal.Token.ValueText;
s = EscapeQuote(s);
s = DoubleBraces(s);
sb.Append(s);
}
else
{
string s = GetInnerText(literal.Token.Text);
s = DoubleBraces(s);
sb.Append(s);
}
}
else if (kind == SyntaxKind.InterpolatedStringExpression)
{
var interpolatedString = (InterpolatedStringExpressionSyntax)Expressions[i];
bool isVerbatimInterpolatedString = interpolatedString.IsVerbatim();
foreach (InterpolatedStringContentSyntax content in interpolatedString.Contents)
{
SyntaxKind contentKind = content.Kind();
Debug.Assert(content.IsKind(SyntaxKind.Interpolation, SyntaxKind.InterpolatedStringText), content.Kind().ToString());
if (contentKind == SyntaxKind.InterpolatedStringText)
{
var text = (InterpolatedStringTextSyntax)content;
if (ContainsRegular &&
isVerbatimInterpolatedString)
{
string s = text.TextToken.ValueText;
s = EscapeQuote(s);
sb.Append(s);
}
else
{
sb.Append(content.ToString());
}
}
else if (contentKind == SyntaxKind.Interpolation)
{
sb.Append(content.ToString());
}
}
}
else
{
sb.Append('{');
sb.Append(Expressions[i].ToString());
sb.Append('}');
}
}
sb.Append("\"");
return((InterpolatedStringExpressionSyntax)SyntaxFactory.ParseExpression(sb.ToString()));
}
/// <summary>
/// Injects an if statement with the original code or the mutated one, depending on condition's result.
/// </summary>
/// <param name="condition">Expression for the condition.</param>
/// <param name="originalNode">Original code</param>
/// <param name="mutatedNode">Mutated code</param>
/// <returns>A statement containing the expected construct.</returns>
/// <remarks>This method works with statement and block.</remarks>
public IfStatementSyntax InjectIf(ExpressionSyntax condition, StatementSyntax originalNode, StatementSyntax mutatedNode) =>
SyntaxFactory.IfStatement(condition,
AsBlock(mutatedNode),
SyntaxFactory.ElseClause(AsBlock(originalNode))).WithAdditionalAnnotations(Marker);
/// <summary>
/// Finds the local function, anonymous function, method, accessor, or ctor that most directly owns a given syntax node.
/// </summary>
/// <param name="syntaxNode">The syntax node to begin the search from.</param>
/// <returns>The containing function, and metadata for it.</returns>
internal static ContainingFunctionData GetContainingFunction(CSharpSyntaxNode syntaxNode)
{
while (syntaxNode != null)
{
if (syntaxNode is SimpleLambdaExpressionSyntax simpleLambda)
{
return(new ContainingFunctionData(simpleLambda, simpleLambda.AsyncKeyword != default(SyntaxToken), SyntaxFactory.ParameterList().AddParameters(simpleLambda.Parameter), simpleLambda.Body));
}
if (syntaxNode is AnonymousMethodExpressionSyntax anonymousMethod)
{
return(new ContainingFunctionData(anonymousMethod, anonymousMethod.AsyncKeyword != default(SyntaxToken), anonymousMethod.ParameterList, anonymousMethod.Body));
}
if (syntaxNode is ParenthesizedLambdaExpressionSyntax lambda)
{
return(new ContainingFunctionData(lambda, lambda.AsyncKeyword != default(SyntaxToken), lambda.ParameterList, lambda.Body));
}
if (syntaxNode is AccessorDeclarationSyntax accessor)
{
return(new ContainingFunctionData(accessor, false, SyntaxFactory.ParameterList(), accessor.Body));
}
if (syntaxNode is BaseMethodDeclarationSyntax method)
{
return(new ContainingFunctionData(method, method.Modifiers.Any(SyntaxKind.AsyncKeyword), method.ParameterList, method.Body));
}
syntaxNode = (CSharpSyntaxNode)syntaxNode.Parent;
}
return(default(ContainingFunctionData));
}
private static BlockSyntax CallNativePointerOverload(MethodDeclarationSyntax nativePointerOverload, GeneratorFlags flags, IReadOnlyDictionary <ParameterSyntax, FriendlyFlags> parametersToFriendlyTransform)
{
Func <ParameterSyntax, IdentifierNameSyntax> getLocalSubstituteName = p => SyntaxFactory.IdentifierName(p.Identifier.ValueText + "Local");
var invocationArguments = new Dictionary <ParameterSyntax, ArgumentSyntax>();
foreach (var p in nativePointerOverload.ParameterList.Parameters)
{
var refOrOut = p.Modifiers.FirstOrDefault(m => m.IsKind(SyntaxKind.RefKeyword) || m.IsKind(SyntaxKind.OutKeyword));
invocationArguments[p] = SyntaxFactory
.Argument(SyntaxFactory.IdentifierName(p.Identifier))
.WithRefOrOutKeyword(refOrOut);
}
var prelude = new List <StatementSyntax>();
var postlude = new List <StatementSyntax>();
var fixedStatements = new List <FixedStatementSyntax>();
foreach (var parameter in nativePointerOverload.ParameterList.Parameters.Where(p => p.Type is PointerTypeSyntax))
{
var parameterName = SyntaxFactory.IdentifierName(parameter.Identifier);
var localVarName = getLocalSubstituteName(parameter);
FriendlyFlags friendlyFlags;
if (flags.HasFlag(GeneratorFlags.NativePointerToFriendly) && parametersToFriendlyTransform.TryGetValue(parameter, out friendlyFlags))
{
if (friendlyFlags.HasFlag(FriendlyFlags.Array))
{
var fixedArrayDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier)
.WithInitializer(SyntaxFactory.EqualsValueClause(parameterName));
fixedStatements.Add(SyntaxFactory.FixedStatement(
SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedArrayDecl),
SyntaxFactory.Block()));
invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName);
}
else
{
if (friendlyFlags.HasFlag(FriendlyFlags.Optional))
{
var nullableType = (PointerTypeSyntax)parameter.Type;
var hasValueExpression = SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(parameter.Identifier),
SyntaxFactory.IdentifierName(nameof(Nullable <int> .HasValue)));
var valueExpression = SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(parameter.Identifier),
SyntaxFactory.IdentifierName(nameof(Nullable <int> .Value)));
var defaultExpression = SyntaxFactory.DefaultExpression(nullableType.ElementType);
var varStatement = SyntaxFactory.VariableDeclaration(nullableType.ElementType).AddVariables(
SyntaxFactory.VariableDeclarator(localVarName.Identifier)
.WithInitializer(SyntaxFactory.EqualsValueClause(
SyntaxFactory.ConditionalExpression(
hasValueExpression,
valueExpression,
defaultExpression))));
prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement));
if (friendlyFlags.HasFlag(FriendlyFlags.Out))
{
// someParam = someParamLocal;
var assignBackToParameter = SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
parameterName,
localVarName);
var conditionalStatement = SyntaxFactory.IfStatement(
hasValueExpression,
SyntaxFactory.ExpressionStatement(assignBackToParameter));
postlude.Add(conditionalStatement);
}
invocationArguments[parameter] = invocationArguments[parameter].WithExpression(
SyntaxFactory.ConditionalExpression(
hasValueExpression,
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, localVarName),
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
}
else if (friendlyFlags.HasFlag(FriendlyFlags.Out))
{
var fixedDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier)
.WithInitializer(SyntaxFactory.EqualsValueClause(
SyntaxFactory.PrefixUnaryExpression(
SyntaxKind.AddressOfExpression,
parameterName)));
fixedStatements.Add(SyntaxFactory.FixedStatement(
SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedDecl),
SyntaxFactory.Block()));
invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName);
}
else
{
invocationArguments[parameter] = invocationArguments[parameter]
.WithExpression(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, parameterName));
}
}
}
else if (flags.HasFlag(GeneratorFlags.NativePointerToIntPtr))
{
var varStatement = SyntaxFactory.VariableDeclaration(parameter.Type);
var declarator = SyntaxFactory.VariableDeclarator(localVarName.Identifier);
if (parameter.Modifiers.Any(m => m.IsKind(SyntaxKind.OutKeyword)))
{
var assignment = SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
parameterName,
SyntaxFactory.ObjectCreationExpression(
IntPtrTypeSyntax,
SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(localVarName))),
null));
postlude.Add(SyntaxFactory.ExpressionStatement(assignment));
}
else
{
var voidStarPointer = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(parameter.Identifier),
SyntaxFactory.IdentifierName(nameof(IntPtr.ToPointer))),
SyntaxFactory.ArgumentList());
var typedPointer = parameter.Type.Equals(VoidStar)
? (ExpressionSyntax)voidStarPointer
: SyntaxFactory.CastExpression(parameter.Type, voidStarPointer);
declarator = declarator.WithInitializer(SyntaxFactory.EqualsValueClause(typedPointer));
}
varStatement = varStatement.AddVariables(declarator);
prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement));
invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName);
}
}
var invocationExpression = SyntaxFactory.InvocationExpression(
SyntaxFactory.IdentifierName(nativePointerOverload.Identifier.ValueText),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
from p in nativePointerOverload.ParameterList.Parameters
select invocationArguments[p])));
IdentifierNameSyntax resultVariableName = null;
StatementSyntax invocationStatement;
if (nativePointerOverload.ReturnType != null && (nativePointerOverload.ReturnType as PredefinedTypeSyntax)?.Keyword.Kind() != SyntaxKind.VoidKeyword)
{
resultVariableName = SyntaxFactory.IdentifierName("result"); // TODO: ensure this is unique.
invocationStatement = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(nativePointerOverload.ReturnType)
.AddVariables(
SyntaxFactory.VariableDeclarator(resultVariableName.Identifier)
.WithInitializer(SyntaxFactory.EqualsValueClause(invocationExpression))));
}
else
{
invocationStatement = SyntaxFactory.ExpressionStatement(invocationExpression);
}
var block = SyntaxFactory.Block()
.AddStatements(prelude.ToArray())
.AddStatements(invocationStatement)
.AddStatements(postlude.ToArray());
if (resultVariableName != null)
{
ExpressionSyntax returnedValue = nativePointerOverload.ReturnType is PointerTypeSyntax
? (ExpressionSyntax)SyntaxFactory.ObjectCreationExpression(
IntPtrTypeSyntax,
SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(resultVariableName))),
null)
: resultVariableName;
block = block.AddStatements(SyntaxFactory.ReturnStatement(returnedValue));
}
if (fixedStatements.Count > 0)
{
StatementSyntax outermost = block;
foreach (var statement in fixedStatements)
{
outermost = statement.WithStatement(outermost);
}
block = SyntaxFactory.Block(outermost);
}
return(block);
}
/// <summary>
/// injects a 'using' block with static marker class used by coverage logic.
/// </summary>
/// <param name="block"></param>
/// <returns></returns>
public BlockSyntax PlaceStaticContextMarker(BlockSyntax block) =>
SyntaxFactory.Block(
SyntaxFactory.UsingStatement(null, CodeInjection.GetContextClassConstructor(), block)).WithAdditionalAnnotations(Marker);
private TypeSyntax ParseTypeName(string text)
{
return(SyntaxFactory.ParseTypeName(text));
}
public void TestFormattingCharacter()
{
var text = "\u0915\u094d\u200d\u0937";
var tok = SyntaxFactory.ParseToken(text);
Assert.NotEqual(default, tok);
private bool TryRemoveSummaryPrefix(ref SyntaxList <XmlNodeSyntax> summaryContent, string prefix)
{
XmlNodeSyntax firstContent = summaryContent.FirstOrDefault(IsContentElement);
if (!(firstContent is XmlTextSyntax firstText))
{
return(false);
}
string firstTextContent = string.Concat(firstText.DescendantTokens());
if (!firstTextContent.TrimStart().StartsWith(prefix, StringComparison.Ordinal))
{
return(false);
}
// Find the token containing the prefix, such as "Gets or sets "
SyntaxToken prefixToken = default;
foreach (SyntaxToken textToken in firstText.TextTokens)
{
if (textToken.IsMissing)
{
continue;
}
if (!textToken.Text.TrimStart().StartsWith(prefix, StringComparison.Ordinal))
{
continue;
}
prefixToken = textToken;
break;
}
if (prefixToken.IsMissingOrDefault())
{
return(false);
}
string text = prefixToken.Text;
string valueText = prefixToken.ValueText;
int index = text.IndexOf(prefix);
if (index >= 0)
{
bool additionalCharacters = index + prefix.Length < text.Length;
text = text.Substring(0, index)
+ (additionalCharacters ? char.ToUpperInvariant(text[index + prefix.Length]).ToString() : string.Empty)
+ text.Substring(index + (additionalCharacters ? (prefix.Length + 1) : prefix.Length));
}
index = valueText.IndexOf(prefix);
if (index >= 0)
{
valueText = valueText.Remove(index, prefix.Length);
}
SyntaxToken replaced = SyntaxFactory.Token(prefixToken.LeadingTrivia, prefixToken.Kind(), text, valueText, prefixToken.TrailingTrivia);
summaryContent = summaryContent.Replace(firstText, firstText.ReplaceToken(prefixToken, replaced));
return(true);
}
static ITypeSymbol CreateClass(MonoDevelop.Projects.Project project, Stetic.ActionGroupComponent group, string name, string namspace, string folder)
{
string fullName = namspace.Length > 0 ? namspace + "." + name : name;
var type = SyntaxFactory.ClassDeclaration(name)
.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("Gtk.ActionGroup")));
// Generate the constructor. It contains the call that builds the widget.
var members = new SyntaxList <MemberDeclarationSyntax> ();
var ctor = SyntaxFactory.ConstructorDeclaration(
new SyntaxList <AttributeListSyntax> (),
SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)),
SyntaxFactory.Identifier(name),
SyntaxFactory.ParameterList(),
SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseKeyword, SyntaxFactory.ArgumentList(new SeparatedSyntaxList <ArgumentSyntax> {
SyntaxFactory.Argument(SyntaxFactory.ParseExpression(fullName))
})),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.ParseExpression("Stetic.Gui.Build"),
SyntaxFactory.ArgumentList(
new SeparatedSyntaxList <ArgumentSyntax> {
SyntaxFactory.Argument(SyntaxFactory.ThisExpression()),
SyntaxFactory.Argument(SyntaxFactory.ParseExpression(fullName))
}
)
)
)
)
);
type = type.AddMembers(ctor);
// Add signal handlers
foreach (Stetic.ActionComponent action in group.GetActions())
{
foreach (Stetic.Signal signal in action.GetSignals())
{
var parameters = new SeparatedSyntaxList <ParameterSyntax> ();
foreach (var p in signal.SignalDescriptor.HandlerParameters)
{
parameters = parameters.Add(SyntaxFactory.Parameter(new SyntaxList <AttributeListSyntax> (), SyntaxFactory.TokenList(), SyntaxFactory.ParseTypeName(p.TypeName), SyntaxFactory.Identifier(p.Name), null));
}
var met = SyntaxFactory.MethodDeclaration(
new SyntaxList <AttributeListSyntax> (),
SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)),
SyntaxFactory.ParseTypeName(signal.SignalDescriptor.HandlerReturnTypeName),
null,
SyntaxFactory.Identifier(signal.Handler),
null,
SyntaxFactory.ParameterList(parameters),
new SyntaxList <TypeParameterConstraintClauseSyntax> (),
SyntaxFactory.Block(),
null
);
type = type.AddMembers(met);
}
}
// Create the class
return(CodeGenerationService.AddType((DotNetProject)project, folder, namspace, type));
}
private static InvocationExpressionSyntax BuildCorrectCheckThatExpression(
ExpressionSyntax invocationExpression, ITypeSymbol sutType)
{
var checkName = string.Empty;
// deal with well known types
switch (sutType.SpecialType)
{
case SpecialType.System_Boolean:
checkName = "IsTrue";
// When we have a reference type
break;
case SpecialType.System_String:
checkName = "IsNotEmpty";
break;
case SpecialType.System_Enum:
break;
case SpecialType.System_SByte:
case SpecialType.System_Byte:
case SpecialType.System_Int16:
case SpecialType.System_UInt16:
case SpecialType.System_Int32:
case SpecialType.System_UInt32:
case SpecialType.System_Int64:
case SpecialType.System_UInt64:
case SpecialType.System_Decimal:
case SpecialType.System_Single:
case SpecialType.System_Double:
checkName = "IsNotZero";
break;
case SpecialType.System_DateTime:
break;
case SpecialType.System_IAsyncResult:
break;
case SpecialType.System_AsyncCallback:
break;
default:
if (sutType.TypeKind == TypeKind.Array || sutType.AllInterfaces.Any(t =>
t.SpecialType == SpecialType.System_Collections_IEnumerable))
{
return SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
invocationExpression, SyntaxFactory.IdentifierName("Not")),
SyntaxFactory.IdentifierName("IsEmpty")));
}
if (sutType.IsReferenceType ||
sutType.OriginalDefinition?.SpecialType == SpecialType.System_Nullable_T)
{
checkName = "IsNotNull";
}
break;
}
InvocationExpressionSyntax replacementNode;
if (!string.IsNullOrEmpty(checkName))
{
// no fix applied
replacementNode = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
invocationExpression,
SyntaxFactory.IdentifierName(checkName)));
}
else
{
replacementNode = null;
}
return replacementNode;
}
protected override bool TryInitializeSimpleAttributeNameGenerationState(
SemanticDocument document,
SyntaxNode node,
CancellationToken cancellationToken,
out SyntaxToken token,
out IList <ArgumentSyntax> arguments,
out IList <AttributeArgumentSyntax> attributeArguments,
out INamedTypeSymbol typeToGenerateIn)
{
var simpleName = (SimpleNameSyntax)node;
var fullName = simpleName.IsRightSideOfQualifiedName()
? (NameSyntax)simpleName.Parent
: simpleName;
if (fullName.Parent is AttributeSyntax)
{
var attribute = (AttributeSyntax)fullName.Parent;
if (attribute.ArgumentList != null &&
!attribute.ArgumentList.CloseParenToken.IsMissing)
{
var symbolInfo = document.SemanticModel.GetSymbolInfo(attribute, cancellationToken);
if (symbolInfo.CandidateReason == CandidateReason.OverloadResolutionFailure && !symbolInfo.CandidateSymbols.IsEmpty)
{
token = simpleName.Identifier;
attributeArguments = attribute.ArgumentList.Arguments.ToList();
arguments = attributeArguments.Select(x => SyntaxFactory.Argument(x.NameColon ?? ((x.NameEquals != null) ? SyntaxFactory.NameColon(x.NameEquals.Name) : null), default(SyntaxToken), x.Expression)).ToList();
typeToGenerateIn = symbolInfo.CandidateSymbols.FirstOrDefault().ContainingSymbol as INamedTypeSymbol;
return(typeToGenerateIn != null);
}
}
}
token = default(SyntaxToken);
arguments = null;
attributeArguments = null;
typeToGenerateIn = null;
return(false);
}
internal override IMethodSymbol GetDelegatingConstructor(State state, SemanticDocument document, int argumentCount, INamedTypeSymbol namedType, ISet <IMethodSymbol> candidates, CancellationToken cancellationToken)
{
var oldToken = state.Token;
var tokenKind = oldToken.Kind();
if (state.IsConstructorInitializerGeneration)
{
SyntaxToken thisOrBaseKeyword;
SyntaxKind newCtorInitializerKind;
if (tokenKind != SyntaxKind.BaseKeyword && state.TypeToGenerateIn == namedType)
{
thisOrBaseKeyword = SyntaxFactory.Token(SyntaxKind.ThisKeyword);
newCtorInitializerKind = SyntaxKind.ThisConstructorInitializer;
}
else
{
thisOrBaseKeyword = SyntaxFactory.Token(SyntaxKind.BaseKeyword);
newCtorInitializerKind = SyntaxKind.BaseConstructorInitializer;
}
var ctorInitializer = (ConstructorInitializerSyntax)oldToken.Parent;
var oldArgumentList = ctorInitializer.ArgumentList;
var newArgumentList = GetNewArgumentList(oldArgumentList, argumentCount);
var newCtorInitializer = SyntaxFactory.ConstructorInitializer(newCtorInitializerKind, ctorInitializer.ColonToken, thisOrBaseKeyword, newArgumentList);
SemanticModel speculativeModel;
if (document.SemanticModel.TryGetSpeculativeSemanticModel(ctorInitializer.Span.Start, newCtorInitializer, out speculativeModel))
{
var symbolInfo = speculativeModel.GetSymbolInfo(newCtorInitializer, cancellationToken);
return(GenerateConstructorHelpers.GetDelegatingConstructor(symbolInfo, candidates, namedType));
}
}
else
{
var oldNode = oldToken.Parent
.AncestorsAndSelf(ascendOutOfTrivia: false)
.Where(node => SpeculationAnalyzer.CanSpeculateOnNode(node))
.LastOrDefault();
var typeNameToReplace = (TypeSyntax)oldToken.Parent;
TypeSyntax newTypeName;
if (namedType != state.TypeToGenerateIn)
{
while (true)
{
var parentType = typeNameToReplace.Parent as TypeSyntax;
if (parentType == null)
{
break;
}
typeNameToReplace = parentType;
}
newTypeName = namedType.GenerateTypeSyntax().WithAdditionalAnnotations(annotation);
}
else
{
newTypeName = typeNameToReplace.WithAdditionalAnnotations(annotation);
}
var newNode = oldNode.ReplaceNode(typeNameToReplace, newTypeName);
newTypeName = (TypeSyntax)newNode.GetAnnotatedNodes(annotation).Single();
var oldArgumentList = (ArgumentListSyntax)newTypeName.Parent.ChildNodes().FirstOrDefault(n => n is ArgumentListSyntax);
if (oldArgumentList != null)
{
var newArgumentList = GetNewArgumentList(oldArgumentList, argumentCount);
if (newArgumentList != oldArgumentList)
{
newNode = newNode.ReplaceNode(oldArgumentList, newArgumentList);
newTypeName = (TypeSyntax)newNode.GetAnnotatedNodes(annotation).Single();
}
}
var speculativeModel = SpeculationAnalyzer.CreateSpeculativeSemanticModelForNode(oldNode, newNode, document.SemanticModel);
if (speculativeModel != null)
{
var symbolInfo = speculativeModel.GetSymbolInfo(newTypeName.Parent, cancellationToken);
return(GenerateConstructorHelpers.GetDelegatingConstructor(symbolInfo, candidates, namedType));
}
}
return(null);
}
private static ParameterListSyntax TransformParameterList(ParameterListSyntax list, GeneratorFlags generatorFlags, IReadOnlyDictionary <ParameterSyntax, FriendlyFlags> parametersToFriendlyTransform)
{
var resultingList = list.ReplaceNodes(
WhereIsPointerParameter(list.Parameters),
(n1, n2) =>
{
// Remove all attributes
n2 = n2.WithAttributeLists(SyntaxFactory.List <AttributeListSyntax>());
FriendlyFlags friendlyFlags;
if (generatorFlags.HasFlag(GeneratorFlags.NativePointerToFriendly) && parametersToFriendlyTransform.TryGetValue(n1, out friendlyFlags))
{
var pointerType = (PointerTypeSyntax)n2.Type;
var alteredParameter = n2.WithDefault(null);
if (friendlyFlags.HasFlag(FriendlyFlags.Array))
{
alteredParameter = alteredParameter
.WithType(SyntaxFactory.ArrayType(pointerType.ElementType, OneDimensionalUnspecifiedLengthArray));
}
else
{
if (friendlyFlags.HasFlag(FriendlyFlags.Optional))
{
alteredParameter = alteredParameter
.WithType(SyntaxFactory.NullableType(pointerType.ElementType));
}
if (friendlyFlags.HasFlag(FriendlyFlags.Out))
{
SyntaxKind modifier = friendlyFlags.HasFlag(FriendlyFlags.Optional) || friendlyFlags.HasFlag(FriendlyFlags.In)
? SyntaxKind.RefKeyword
: SyntaxKind.OutKeyword;
if (!friendlyFlags.HasFlag(FriendlyFlags.Optional))
{
alteredParameter = alteredParameter
.WithType(pointerType.ElementType);
}
alteredParameter = alteredParameter
.AddModifiers(SyntaxFactory.Token(modifier));
}
else if (!friendlyFlags.HasFlag(FriendlyFlags.Optional))
{
alteredParameter = alteredParameter
.WithType(pointerType.ElementType);
}
}
return(alteredParameter);
}
else if (generatorFlags.HasFlag(GeneratorFlags.NativePointerToIntPtr))
{
return(n2
.WithType(IntPtrTypeSyntax)
.WithDefault(null));
}
else
{
return(n2);
}
});
return(resultingList);
}
private SyntaxNode GetNewBlock(SyntaxNode statement, StatementSyntax statementBody)
{
var body = SyntaxFactory.Block(statementBody);
return(statement.ReplaceNode(statementBody, body));
}
private static SyntaxTokenList RemoveModifier(SyntaxTokenList list, params SyntaxKind[] modifiers)
{
return(SyntaxFactory.TokenList(list.Where(t => Array.IndexOf(modifiers, t.Kind()) < 0)));
}
public override CSharpSyntaxNode VisitModuleDefinition([NotNull] GammerParser.ModuleDefinitionContext context)
{
var namespaces = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(context.moduleName().GetText())
.WithLeadingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")))
.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.SyntaxTrivia(SyntaxKind.EndOfLineTrivia, "\n")))
);
namespaces = namespaces.AddMembers(SyntaxFactory.ClassDeclaration(" Program").AddMembers(SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName("System.Windows.Forms.Timer"), "Ticker")
.AddAccessorListAccessors(
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
.WithInitializer(SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(2))))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
,
SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void"), "Main")
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.WithBody(SyntaxFactory.Block())));
return SyntaxFactory.CompilationUnit().AddMembers(namespaces);
}
/// <inheritdoc />
public Task <SyntaxList <MemberDeclarationSyntax> > GenerateAsync(TransformationContext context, IProgress <Diagnostic> progress, CancellationToken cancellationToken)
{
var applyTo = context.ProcessingNode;
var compilation = context.Compilation;
var semanticModel = compilation.GetSemanticModel(applyTo.SyntaxTree);
var type = (ClassDeclarationSyntax)applyTo;
var generatedType = type
.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>());
var methodsWithNativePointers =
from method in type.Members.OfType <MethodDeclarationSyntax>()
where WhereIsPointerParameter(method.ParameterList.Parameters).Any() || method.ReturnType is PointerTypeSyntax
select method;
foreach (var method in methodsWithNativePointers)
{
var nativePointerParameters = method.ParameterList.Parameters.Where(p => p.Type is PointerTypeSyntax);
var refOrArrayAttributedParameters =
from parameter in nativePointerParameters
let attributes = parameter.AttributeLists.SelectMany(al => al.Attributes)
let friendlyAttribute = attributes.FirstOrDefault(attribute => (attribute.Name as SimpleNameSyntax)?.Identifier.ValueText == "Friendly")
where friendlyAttribute != null
let friendlyFlagsExpression = friendlyAttribute.ArgumentList.Arguments.First().Expression
let friendlyFlags = (FriendlyFlags)(int)semanticModel.GetConstantValue(friendlyFlagsExpression).Value
select new
{
Parameter = parameter,
Flags = friendlyFlags
};
var parametersToFriendlyTransform = refOrArrayAttributedParameters.ToDictionary(p => p.Parameter, p => p.Flags);
// Consider undecorated byte* parameters to have a Friendly attribute by default.
var byteArrayInParameters = nativePointerParameters.Where(IsByteStarInParameter);
foreach (var p in byteArrayInParameters)
{
if (!parametersToFriendlyTransform.ContainsKey(p))
{
parametersToFriendlyTransform[p] = FriendlyFlags.Array | FriendlyFlags.Bidirectional;
}
}
var transformedMethodBase = method
.WithReturnType(TransformReturnType(method.ReturnType))
.WithIdentifier(TransformMethodName(method))
.WithModifiers(RemoveModifier(method.Modifiers, SyntaxKind.ExternKeyword))
.WithAttributeLists(FilterAttributes(method.AttributeLists))
.WithLeadingTrivia(method.GetLeadingTrivia().Where(t => !t.IsDirective))
.WithTrailingTrivia(method.GetTrailingTrivia().Where(t => !t.IsDirective))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None))
.WithExpressionBody(null);
var flags = GeneratorFlags.NativePointerToIntPtr;
var intPtrOverload = transformedMethodBase
.WithParameterList(TransformParameterList(method.ParameterList, flags, parametersToFriendlyTransform))
.WithBody(CallNativePointerOverload(method, flags, parametersToFriendlyTransform));
generatedType = generatedType.AddMembers(intPtrOverload);
if (parametersToFriendlyTransform.Count > 0)
{
flags = GeneratorFlags.NativePointerToIntPtr | GeneratorFlags.NativePointerToFriendly;
var byteArrayAndIntPtrOverload = transformedMethodBase
.WithParameterList(TransformParameterList(method.ParameterList, flags, parametersToFriendlyTransform))
.WithBody(CallNativePointerOverload(method, flags, parametersToFriendlyTransform));
generatedType = generatedType.AddMembers(byteArrayAndIntPtrOverload);
// If there are native pointers that aren't "friendly", it would produce a unique method signature
// for a method that only converts the friendly parameters and leaves other native pointers alone.
if (nativePointerParameters.Except(parametersToFriendlyTransform.Keys).Any())
{
flags = GeneratorFlags.NativePointerToFriendly;
var friendlyOverload = transformedMethodBase
.WithParameterList(TransformParameterList(method.ParameterList, flags, parametersToFriendlyTransform))
.WithBody(CallNativePointerOverload(method, flags, parametersToFriendlyTransform));
generatedType = generatedType.AddMembers(friendlyOverload);
}
}
}
return(Task.FromResult(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(generatedType)));
}
public override Microsoft.CodeAnalysis.SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
{
FieldDeclarationSyntax newNode = null;
var parent = node.Parent;
// Verify we have the correct context for the Field Declaration
switch (_declarationLocation)
{
case SyntaxNode.FieldDeclarationLocation.Class:
if (parent.Kind() != SyntaxKind.ClassBlock)
{
return(node);
}
break;
case SyntaxNode.FieldDeclarationLocation.Module:
if (parent.Kind() != SyntaxKind.ModuleBlock)
{
return(node);
}
break;
case SyntaxNode.FieldDeclarationLocation.Structure:
if (parent.Kind() != SyntaxKind.StructureBlock)
{
return(node);
}
break;
}
if (_targetPatternRegEx.Match(node.Declarators.First().Names.First().Identifier.ToString()).Success)
{
try
{
// Verify this expression is on line by itself. May not need to do this.
// See if can have multiple FieldDeclarations on same line.
if (VNCCA.Helpers.VB.IsOnLineByItself(node))
{
// HACK(crhodes)
// Figure out how to get Helpers to work here.
Messages.AppendLine(String.Format("Removing {0} {1}",
VNCCA.Helpers.VB.GetContainingContext(node, _configurationOptions),
node.ToString()));
if (_commentOutOnly)
{
List <SyntaxTrivia> newTrivia = new List <SyntaxTrivia>();
string existingLeadingTrivia = node.GetLeadingTrivia().ToString();
string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString();
string existingTrailingTrivia = node.GetTrailingTrivia().ToString();
string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString();
string startOfLineWhiteSpace = existingLeadingTrivia.Replace(System.Environment.NewLine, "");
newTrivia.Add(SyntaxFactory.CommentTrivia(existingLeadingTriviaFull));
newTrivia.Add(SyntaxFactory.CommentTrivia(VNCCA.Helpers.VB.MultiLineComment(_comment, startOfLineWhiteSpace)));
newTrivia.Add(SyntaxFactory.CommentTrivia("' "));
newNode = node.WithLeadingTrivia(newTrivia);
}
else
{
// This removes the node
newNode = null;
}
}
else
{
Messages.AppendLine(String.Format("node: >{0}< >{1}< Is NOT OnLineByItself", node.ToString(), node.ToFullString()));
newNode = node;
}
}
catch (Exception ex)
{
Messages.AppendLine(string.Format("Ex:{0} InnerEx:{1}", ex.ToString(), ex.InnerException.ToString()));
}
}
else
{
newNode = node;
}
return(newNode);
}
#pragma warning restore
public async Task AppendingUnrelatedSource_DoesNotRegenerateSource()
{
string source = $"namespace NS{{{CodeSnippets.BasicParametersAndModifiers<int>()}}}";
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview));
Compilation comp1 = await TestUtils.CreateCompilation(new[] { syntaxTree });
Microsoft.Interop.DllImportGenerator generator = new();
GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new[] { generator });
driver = driver.RunGenerators(comp1);
generator.IncrementalTracker = new IncrementalityTracker();
SyntaxTree newTree = syntaxTree.WithRootAndOptions(syntaxTree.GetCompilationUnitRoot().AddMembers(SyntaxFactory.ParseMemberDeclaration("struct Foo {}") !), syntaxTree.Options);
Compilation comp2 = comp1.ReplaceSyntaxTree(comp1.SyntaxTrees.First(), newTree);
driver.RunGenerators(comp2);
Assert.Collection(generator.IncrementalTracker.ExecutedSteps,
step =>
{
Assert.Equal(IncrementalityTracker.StepName.CalculateStubInformation, step.Step);
});
}
private IEnumerable<SyntaxTree> GeneratedSyntaxTrees()
{
yield return SyntaxFactory.ParseSyntaxTree($"[assembly: {typeof(CompiledFromDirectoryAttribute).FullName}(@\"{CurrentDirectory.FullName}\")]", CscArgs.ParseOptions);
}
private static BlockSyntax AsBlock(StatementSyntax code) => code as BlockSyntax ?? SyntaxFactory.Block(code);
public static SyntaxToken GetStubDefinitionIdentifier(string originalName)
{
return(SyntaxFactory.Identifier(originalName + "Def"));
}
private SyntaxTree InjectMutationLabel(SyntaxTree syntaxTree)
{
var root = syntaxTree.GetRoot();
var myAttribute = ((CompilationUnitSyntax)root).AttributeLists
.SelectMany(al => al.Attributes).FirstOrDefault(n => n.Name.Kind() == SyntaxKind.QualifiedName &&
((QualifiedNameSyntax)n.Name).Right
.Kind() == SyntaxKind.IdentifierName &&
(string)((IdentifierNameSyntax)((QualifiedNameSyntax)n.Name).Right)
.Identifier.Value == "AssemblyTitleAttribute");
var labelNode = myAttribute?.ArgumentList.Arguments.First()?.Expression;
var newLabel = string.Empty;
if (labelNode != null && labelNode.Kind() == SyntaxKind.StringLiteralExpression)
{
var literal = (LiteralExpressionSyntax)labelNode;
newLabel = $"Mutated {literal.Token.Value}";
}
if (myAttribute != null)
{
var newAttribute = myAttribute.ReplaceNode(labelNode,
SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(newLabel)));
root = root.ReplaceNode(myAttribute, newAttribute);
return(root.SyntaxTree);
}
return(syntaxTree);
}
public static IdentifierNameSyntax GetStubDefinitionIdentifierName(string originalName)
{
return(SyntaxFactory.IdentifierName(originalName + "Def"));
}
private IView GenerateExecutableCоde(string csharpCode, object viewModel)
{
var compileResult = CSharpCompilation.Create("ViewAssembly")
.WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddReferences(MetadataReference.CreateFromFile(typeof(IView).Assembly.Location));
if (viewModel != null)
{
if (viewModel.GetType().IsGenericType)
{
var genericArguments = viewModel.GetType().GenericTypeArguments;
foreach (var genericArgument in genericArguments)
{
compileResult = compileResult
.AddReferences(MetadataReference.CreateFromFile(genericArgument.Assembly.Location));
}
}
compileResult = compileResult
.AddReferences(MetadataReference.CreateFromFile(viewModel.GetType().Assembly.Location));
}
var libraries = Assembly.Load(new AssemblyName("netstandard"))
.GetReferencedAssemblies();
foreach (var library in libraries)
{
compileResult = compileResult
.AddReferences(MetadataReference.CreateFromFile(
Assembly.Load(library).Location));
}
compileResult = compileResult.AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree(csharpCode));
using (MemoryStream memoryStream = new MemoryStream())
{
EmitResult result = compileResult.Emit(memoryStream);
if (!result.Success)
{
return(new ErrorView(result.Diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => x.GetMessage()), csharpCode));
}
try
{
memoryStream.Seek(0, SeekOrigin.Begin);
var byteAssembly = memoryStream.ToArray();
var assembly = Assembly.Load(byteAssembly);
var viewType = assembly.GetType("ViewNamespace.ViewClass");
var instance = Activator.CreateInstance(viewType);
return((instance as IView) ?? new ErrorView(new List <string> {
"Instance is null!"
}, csharpCode));
}
catch (Exception ex)
{
return(new ErrorView(new List <string> {
ex.ToString()
}, csharpCode));
}
}
}
private static PrefixUnaryExpressionSyntax NegateCondition(ExpressionSyntax expressionSyntax)
{
return(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, SyntaxFactory.ParenthesizedExpression(expressionSyntax)));
}
public void MutantPlacer_ShouldPlaceWithIfStatement(int id)
{
// 1 + 8;
var originalNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8))));
// 1 - 8;
var mutatedNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8))));
var result = MutantPlacer.PlaceWithIfStatement(originalNode, mutatedNode, id);
result.ToFullString().ShouldBeSemantically("if (" + CodeInjection.HelperNamespace + ".MutantControl.IsActive(" + id + @"))
{
1 - 8;
} else {
1 + 8;
}");
var removedResult = MutantPlacer.RemoveMutant(result);
removedResult.ToString().ShouldBeSemantically(originalNode.ToString());
}
private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
IMethodSymbol accessor,
SyntaxKind kind,
bool hasBody)
{
return(AddAnnotationsTo(accessor, SyntaxFactory.AccessorDeclaration(kind)
.WithBody(hasBody ? GenerateBlock(accessor) : null)
.WithSemicolonToken(hasBody ? default(SyntaxToken) : SyntaxFactory.Token(SyntaxKind.SemicolonToken))));
}
