private static void CheckPropertyML(
Action <Diagnostic> reportDiagnostic,
PropertyValueSyntax propValue,
string name,
string kindName)
{
// ISSUE: variable of a compiler-generated type
CommaSeparatedIdentifierEqualsStringListSyntax stringListSyntax = ((MultilanguagePropertyValueSyntax)propValue).Value;
if (stringListSyntax.Values.Count <= 0)
{
return;
}
foreach (IdentifierEqualsStringSyntax equalsStringSyntax in stringListSyntax.Values)
{
Action <Diagnostic> reportDiagnostic1 = reportDiagnostic;
// ISSUE: variable of a compiler-generated type
StringLiteralValueSyntax stringLiteral = equalsStringSyntax.StringLiteral;
string input = stringLiteral != null?SyntaxNodeExtensions.GetLiteralValue(stringLiteral).ToString() : (string)null;
Location location = propValue.GetLocation();
string kindName1 = kindName;
string name1 = name;
EmailAndPhoneNoMustNotBePresentInTheSource.VerifyValue(reportDiagnostic1, input, location, kindName1, name1);
}
}
public static CompilationUnitSyntax Generate(XDocument vsctDocument, string desiredNamespaceName)
{
VisualStudioWorkspace componentModelService = Services.GetComponentModelService <VisualStudioWorkspace>();
return((CompilationUnitSyntax)Formatter.Format(SyntaxFactory.CompilationUnit().WithUsings(SyntaxFactory.List <UsingDirectiveSyntax>(new UsingDirectiveSyntax[3]
{
SyntaxNodeExtensions.WithLeadingTrivia(Usings.System, GenerateAutoGeneratedHeader()),
Usings.SystemComponentModelDesign,
Usings.MicrosoftVisualStudioShell
})).AddMembers(new MemberDeclarationSyntax[1]
{
SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(desiredNamespaceName)).AddMembers(new MemberDeclarationSyntax[1]
{
ClassGenerator.GeneratePackageGuidsClass(vsctDocument)
}).AddMembers(new MemberDeclarationSyntax[1]
{
ClassGenerator.GeneratePackageIdsClass(vsctDocument)
}).AddMembers(new MemberDeclarationSyntax[1]
{
ClassGenerator.GenerateCommandIdsClass(vsctDocument)
}).AddMembers(new MemberDeclarationSyntax[1]
{
ClassGenerator.GenerateAbstractCommandFacadeClass(vsctDocument)
}).AddMembers(new MemberDeclarationSyntax[1]
{
ClassGenerator.GenerateCommandFacadeClass()
}).AddMembers(new MemberDeclarationSyntax[1]
{
ClassGenerator.GenerateCommandRegistrarClass(vsctDocument)
})
}), componentModelService, null, new CancellationToken()));
}
public SyntaxTree Replace(SyntaxTree st)
{
#region CodeContracts
Contract.Requires(st != null);
Contract.Ensures(Contract.Result <SyntaxTree>() != null);
#endregion CodeContracts
return(SyntaxNodeExtensions.ReplaceNodes(st.GetRoot(), dict_old_to_new.Keys, ComputeReplacement).SyntaxTree);
}
private static void ApplyFix(DocumentEditor editor, ArgumentSyntax argument, string name, CancellationToken cancellationToken)
{
if (!IsStaticContext(argument, editor.SemanticModel, cancellationToken) &&
editor.SemanticModel.LookupSymbols(argument.SpanStart, name: name).TrySingle(out var member) &&
(member is IFieldSymbol || member is IPropertySymbol || member is IMethodSymbol) &&
!member.IsStatic &&
!editor.SemanticModel.UnderscoreFields())
{
editor.ReplaceNode(
argument.Expression,
(x, _) => SyntaxNodeExtensions.WithTriviaFrom(SyntaxFactory.ParseExpression($"nameof(this.{name})"), x));
}
public static MethodDeclarationSyntax GenerateFacadeCommandMethod(string commandName)
{
return(SyntaxNodeExtensions.WithLeadingTrivia(SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token((SyntaxKind)8318)), SyntaxFactory.Identifier(commandName)).WithModifiers(Modifiers.PublicVirtual).WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(new SyntaxNodeOrToken[3]
{
SyntaxFactory.Parameter(SyntaxFactory.Identifier("sender")).WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token((SyntaxKind)8319))),
SyntaxFactory.Token((SyntaxKind)8216),
SyntaxFactory.Parameter(SyntaxFactory.Identifier("e")).WithType(SyntaxFactory.IdentifierName("EventArgs"))
})))).WithBody(SyntaxFactory.Block()).WithTrailingTrivia(SyntaxFactory.TriviaList(new[]
{
SyntaxFactory.CarriageReturnLineFeed,
SyntaxFactory.CarriageReturnLineFeed
})));
}
private async Task <Document> ConfigureAwaitAsync(Document document, ExpressionSyntax invocationExpression, SyntaxKind configureAwaitLiteral, CancellationToken cancellationToken)
{
MemberAccessExpressionSyntax memberAccessExpressionSyntax = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, invocationExpression, SyntaxFactory.IdentifierName("ConfigureAwait"));
SyntaxToken syntaxToken = SyntaxFactory.Token(SyntaxKind.OpenParenToken);
List <ArgumentSyntax> argumentSyntaxes = new List <ArgumentSyntax>()
{
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(configureAwaitLiteral))
};
InvocationExpressionSyntax invocationExpressionSyntax = SyntaxFactory.InvocationExpression(memberAccessExpressionSyntax, SyntaxFactory.ArgumentList(syntaxToken, SyntaxFactory.SeparatedList <ArgumentSyntax>(argumentSyntaxes), SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SyntaxNode syntaxNode = SyntaxNodeExtensions.ReplaceNode <SyntaxNode>(root, invocationExpression, invocationExpressionSyntax);
return(document.WithSyntaxRoot(syntaxNode));
}
static void Main(string[] args)
{
var tree = SyntaxFactory.ParseExpression("(x + y) * z").SyntaxTree;
var root = (BinaryExpressionSyntax)tree.GetRoot();
foreach (var i in root.DescendantNodes())
{
if (i.Kind() == SyntaxKind.IdentifierName)
{
string str = "64";
var subTree = SyntaxFactory.ParseExpression(str).SyntaxTree;
var subRoot = (LiteralExpressionSyntax)subTree.GetRoot();
var newRoot = SyntaxNodeExtensions.ReplaceNode(root, i, subRoot);
Console.WriteLine(newRoot);
}
}
Console.ReadLine();
}
internal static bool HasParenthesisSpacing(this SyntaxNode @this)
{
var children = @this.ChildNodesAndTokens().ToArray();
var openParen = (SyntaxToken?)children.FirstOrDefault(_ => _.IsKind(SyntaxKind.OpenParenToken));
var closeParen = (SyntaxToken?)children.LastOrDefault(_ => _.IsKind(SyntaxKind.CloseParenToken));
var hasSpaceAfterOpenParen = openParen is not null && openParen.Value.HasTrailingTrivia &&
openParen.Value.TrailingTrivia.Any(_ => _.IsKind(SyntaxKind.WhitespaceTrivia));
if (hasSpaceAfterOpenParen && closeParen is not null)
{
var previousNodeIndex = Array.IndexOf(children, closeParen.Value) - 1;
var lastNodeOrToken = SyntaxNodeExtensions.GetLastNodeOrToken(children[previousNodeIndex]);
var hasSpaceBeforeCloseParen = lastNodeOrToken.HasTrailingTrivia &&
lastNodeOrToken.GetTrailingTrivia().Any(_ => _.IsKind(SyntaxKind.WhitespaceTrivia));
return(hasSpaceBeforeCloseParen);
}
return(false);
}
private static SeparatedSyntaxList <ParameterSyntax> FindTypes(SeparatedSyntaxList <ParameterSyntax> parameters, bool isSimpleTypesMode)
{
// per ms docs, "...Simple types include the .NET primitive types (int, bool, double, and so forth), plus TimeSpan, DateTime, Guid, decimal, and string,..."
// https://docs.microsoft.com/en-us/aspnet/web-api/overview/formats-and-model-binding/parameter-binding-in-aspnet-web-api
// below is not the complete list but the most common ones we use
var simpeTypes = new HashSet <string>
{
"int",
"string",
"bool",
"DateTime",
"int?",
"bool?",
"DateTime?",
};
var typeParameters = parameters
.Where(parameter =>
{
string parameterType = SyntaxNodeExtensions.NormalizeWhitespace <TypeSyntax>(parameter
.Type)
.ToFullString();
var hasOutKeyword = OutKeywordGenerator.HasOutKeyword(parameter);
// 'out' keywords will be treated as complex types even if simple type
var hasSimpleTypes = simpeTypes.Contains(parameterType) && !hasOutKeyword;
return(hasSimpleTypes == isSimpleTypesMode);
})
.ToList();
var typeParameterList = new SeparatedSyntaxList <ParameterSyntax>().AddRange(typeParameters);
return(typeParameterList);
}
public static string FormatSourceCode(string sourceCode) => SyntaxNodeExtensions .NormalizeWhitespace(CSharpSyntaxTree.ParseText(sourceCode).GetRoot()) .ToFullString();
public static async Task <Document> ReplaceFromDocumentAsync(this Document document, SyntaxNode oldNode, SyntaxNode newNode, CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode syntaxNode = SyntaxNodeExtensions.ReplaceNode(await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false), oldNode, newNode);
return(document.WithSyntaxRoot(syntaxNode));
}
public static async Task <Document> RemoveFromDocumentAsync(this Document document, SyntaxNode node, CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode syntaxNode = SyntaxNodeExtensions.RemoveNode(await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false), node, SyntaxRemoveOptions.KeepDirectives);
return(document.WithSyntaxRoot(syntaxNode));
}
public static async Task <Solution> MoveTypeToFileAsync(this Document document, ClassDeclarationSyntax typeDecl, CancellationToken cancellationToken = default(CancellationToken))
{
CompilationUnitSyntax compilationUnitSyntax = (CompilationUnitSyntax)(await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false));
IEnumerable <MemberDeclarationSyntax> arg_B5_0 = compilationUnitSyntax.Members;
Func <MemberDeclarationSyntax, bool> arg_B5_1;
if ((arg_B5_1 = MoveTypeToFileFunction) == null)
{
arg_B5_1 = (MoveTypeToFileFunction = new Func <MemberDeclarationSyntax, bool>(m => Microsoft.CodeAnalysis.CSharpExtensions.IsKind(m, SyntaxKind.NamespaceDeclaration)));
}
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
MethodDeclarationSyntax initializeComponentMethod = typeDecl.DescendantNodes().OfType <MethodDeclarationSyntax>().Single(m => m.Identifier.ValueText == "InitializeComponent" && m.ParameterList.Parameters.Count == 0);
var localVars = typeDecl.DescendantNodes().OfType <FieldDeclarationSyntax>().ToDictionary(fds => fds.DescendantNodes().OfType <VariableDeclaratorSyntax>().Single().Identifier.Text);
var simpleAssigns = initializeComponentMethod.Body.DescendantNodes().OfType <MemberAccessExpressionSyntax>().Where(mea => mea.Kind() == SyntaxKind.SimpleMemberAccessExpression && mea.ChildNodes().OfType <ThisExpressionSyntax>().Any()).SelectMany(id => id.DescendantNodes().OfType <IdentifierNameSyntax>()).Select(i => i.Identifier.Text).Distinct().ToList();
NamespaceDeclarationSyntax namespaceDeclarationSyntax = (NamespaceDeclarationSyntax)arg_B5_0.Single(arg_B5_1);
Solution solution = document.Project.Solution;
DocumentId documentId = DocumentId.CreateNewId(document.Project.Id, null);
List <SyntaxNode> toBeDeleted = new List <SyntaxNode>();
toBeDeleted.Add(initializeComponentMethod);
foreach (var item in localVars)
{
if (simpleAssigns.Contains(item.Key))
{
toBeDeleted.Add(item.Value);
}
}
var oldType = SyntaxNodeExtensions.RemoveNodes(typeDecl, toBeDeleted, SyntaxRemoveOptions.KeepDirectives).AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword));
solution = document.ReplaceFromDocumentAsync(typeDecl, oldType, cancellationToken).Result.Project.Solution;
var modifiers = SyntaxFactory.TokenList(new SyntaxToken[] { SyntaxFactory.Token(SyntaxKind.PartialKeyword) });
var newType = SyntaxFactory.ClassDeclaration(typeDecl.Identifier).WithModifiers(modifiers);
var method1 = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), "InitializeComponent");
method1 = method1.WithBody(initializeComponentMethod.Body);
newType = newType.AddMembers(method1);
foreach (var item in localVars)
{
if (simpleAssigns.Contains(item.Key))
{
var varMod = SyntaxFactory.TokenList(item.Value.Modifiers.Select(t => SyntaxFactory.Token(t.Kind())).ToArray());
newType = newType.AddMembers(SyntaxFactory.FieldDeclaration(item.Value.AttributeLists, varMod, item.Value.Declaration));
}
}
solution = solution.AddDocument(documentId, Path.GetFileNameWithoutExtension(document.Name) + ".designer" + Path.GetExtension(document.Name), newType.GetText(), document.Folders, null, true);
CompilationUnitSyntax compilationUnitSyntax2 = SyntaxFactory.CompilationUnit().AddUsings(compilationUnitSyntax.Usings.ToArray()).AddMembers(new MemberDeclarationSyntax[]
{
SyntaxNodeExtensions.WithLeadingTrivia(SyntaxNodeExtensions.NormalizeWhitespace(SyntaxFactory.NamespaceDeclaration(namespaceDeclarationSyntax.Name), " ", false), new SyntaxTrivia[]
{
SyntaxFactory.Whitespace("\r\n")
}).AddMembers(new MemberDeclarationSyntax[] { newType })
});
return(solution.WithDocumentSyntaxRoot(documentId, compilationUnitSyntax2, 0));
}
public static async Task <string> DownloadRestToCodeAsync(
string jsonUrl,
string jsonToCodeApiUrl,
string nameSpace,
string downloadPath)
{
string str1 = "OK ";
try
{
if (string.IsNullOrEmpty(jsonUrl))
{
return("jsonUrl is empty ");
}
if (string.IsNullOrEmpty(jsonToCodeApiUrl))
{
return("jsonToCodeApiUrl is empty ");
}
if (string.IsNullOrEmpty(downloadPath))
{
return("No download path present ");
}
string path = downloadPath;
string str2 = string.Empty;
using (HttpClient httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(jsonUrl);
Task <HttpResponseMessage> async = httpClient.GetAsync(jsonUrl);
if (async != null)
{
str2 = async.Result.Content.ReadAsStringAsync().Result;
}
}
byte[] numArray = new byte[str2.Length * 2];
Buffer.BlockCopy((Array)str2.ToCharArray(), 0, (Array)numArray, 0, numArray.Length);
StringContent stringContent = new StringContent(JsonConvert.SerializeObject((object)new JsonToCode.JsonObject()
{
Culture = "en-us",
JsonBytes = numArray,
NameSpace = nameSpace
}), Encoding.UTF8, "application/json");
using (HttpClient client = new HttpClient())
{
using (HttpResponseMessage httpResponseMessage = await client.PostAsync(jsonToCodeApiUrl, (HttpContent)stringContent))
{
using (HttpContent content = httpResponseMessage.Content)
{
str1 = HttpUtility.HtmlDecode(content.ReadAsStringAsync().Result);
if (str1 == null)
{
return("Code Generation failed ");
}
str1 = str1.Remove(0, 2);
str1 = str1.Remove(str1.Length - 2);
List <char> list1 = str1.ToList <char>();
StringBuilder stringBuilder = new StringBuilder();
char ch;
for (int index = 0; index < list1.Count; ++index)
{
ch = list1[index];
if (ch.Equals(','))
{
ch = list1[index - 1];
if (ch.Equals('"'))
{
list1.Remove(list1[index - 1]);
}
stringBuilder.Append(list1[index - 1]);
}
else
{
stringBuilder.Append(list1[index]);
}
}
str1 = stringBuilder.ToString();
str1 = Regex.Replace(str1, "\\\\n", "");
str1 = Regex.Replace(str1, "\\\\r", "");
str1 = Regex.Replace(str1, "\\\\t", "");
str1 = Regex.Replace(str1, "\\\\", "");
str1 = Regex.Replace(str1, "\"\\\"", "");
str1 = Regex.Replace(str1, "<", "<");
str1 = Regex.Replace(str1, ">", ">");
List <string> list2 = ((IEnumerable <string>)str1.Split(',')).ToList <string>();
for (int index1 = 0; index1 < list2.Count; ++index1)
{
string text = list2[index1];
ch = text[text.Length - 1];
if (ch.Equals('"'))
{
text = text.Remove(text.Length - 1);
}
string[] strArray = text.Split(' ');
for (int index2 = 0; index2 < strArray.Length; ++index2)
{
if (strArray[index2].Contains("class"))
{
string str3 = strArray[index2 + 1].Split('{').GetValue(0).ToString();
if (index2 <= strArray.Length)
{
using (FileStream fileStream = File.Create(path + str3 + ".cs"))
{
byte[] bytes = new UTF8Encoding(true).GetBytes(((SyntaxNode)SyntaxNodeExtensions.NormalizeWhitespace <SyntaxNode>(CSharpSyntaxTree.ParseText(text, (CSharpParseOptions)null, "", (Encoding)null, new CancellationToken()).GetRoot(new CancellationToken()), " ", "\r\n", false)).ToFullString());
fileStream.Write(bytes, 0, bytes.Length);
}
}
else
{
break;
}
}
}
}
}
}
}
return(str1 + " ");
}
catch (Exception ex)
{
return(ex.Message);
}
}
public static async Task <string> DownloadRestWsdlToCodeAsync(
string wsdlUrl,
string wsdlToCodeApiUrl,
string nameSpace,
string downloadPath)
{
string str1 = "OK ";
try
{
if (string.IsNullOrEmpty(wsdlUrl))
{
return("wsdlUrl is empty ");
}
if (string.IsNullOrEmpty(wsdlToCodeApiUrl))
{
return("wsdlToCodeApiUrl is empty ");
}
if (string.IsNullOrEmpty(downloadPath))
{
return("No download path present ");
}
string path = downloadPath;
Uri uri = new Uri(wsdlUrl);
if (uri.Query == string.Empty)
{
uri = new UriBuilder(uri)
{
Query = "WSDL"
}
}
.Uri;
byte[] array;
using (MemoryStream memoryStream = new MemoryStream())
{
WebRequest.Create(uri).GetResponse().GetResponseStream().CopyTo((Stream)memoryStream);
array = memoryStream.ToArray();
}
StringContent stringContent = new StringContent(JsonConvert.SerializeObject((object)new RestWsdlToCode.WsdlObject()
{
WsdlStream = array,
NameSpace = nameSpace
}), Encoding.UTF8, "application/json");
using (HttpClient client = new HttpClient())
{
using (HttpResponseMessage httpResponseMessage = await client.PostAsync(wsdlToCodeApiUrl, (HttpContent)stringContent))
{
using (HttpContent content = httpResponseMessage.Content)
{
str1 = HttpUtility.HtmlDecode(content.ReadAsStringAsync().Result);
if (str1 == null)
{
return("Code Generation failed ");
}
str1 = str1.Remove(0, 2);
str1 = str1.Remove(str1.Length - 2);
List <char> list1 = str1.ToList <char>();
StringBuilder stringBuilder = new StringBuilder();
char ch;
for (int index = 0; index < list1.Count; ++index)
{
ch = list1[index];
if (ch.Equals(','))
{
ch = list1[index - 1];
if (ch.Equals('"'))
{
list1.Remove(list1[index - 1]);
}
stringBuilder.Append(list1[index - 1]);
}
else
{
stringBuilder.Append(list1[index]);
}
}
str1 = stringBuilder.ToString();
str1 = Regex.Replace(str1, "\\\\n", "");
str1 = Regex.Replace(str1, "\\\\r", "");
str1 = Regex.Replace(str1, "\\\\", "");
str1 = Regex.Replace(str1, "\"\\\"", "");
str1 = Regex.Replace(str1, "<", "<");
str1 = Regex.Replace(str1, ">", ">");
List <string> list2 = ((IEnumerable <string>)str1.Split(',')).ToList <string>();
for (int index1 = 0; index1 < list2.Count; ++index1)
{
string str2 = list2[index1];
ch = str2[str2.Length - 1];
if (ch.Equals('"'))
{
str2 = str2.Remove(str2.Length - 1);
}
string[] strArray = str2.Split(' ');
for (int index2 = 0; index2 < strArray.Length; ++index2)
{
if (strArray[index2].Contains("class"))
{
string str3 = strArray[index2 + 1];
if (index2 <= strArray.Length)
{
using (FileStream fileStream = System.IO.File.Create(path + str3 + ".cs"))
{
byte[] bytes = new UTF8Encoding(true).GetBytes(((SyntaxNode)SyntaxNodeExtensions.NormalizeWhitespace <SyntaxNode>(CSharpSyntaxTree.ParseText(str2, (CSharpParseOptions)null, "", (Encoding)null, new CancellationToken()).GetRoot(new CancellationToken()), " ", "\r\n", false)).ToFullString());
fileStream.Write(bytes, 0, bytes.Length);
}
}
else
{
break;
}
}
}
}
}
}
}
return(str1 + " ");
}
