void ResolveButtonClick(object sender, EventArgs e) { IProjectContent project = new CSharpProjectContent(); var unresolvedFile = syntaxTree.ToTypeSystem(); project = project.AddOrUpdateFiles(unresolvedFile); project = project.AddAssemblyReferences(builtInLibs.Value); ICompilation compilation = project.CreateCompilation(); ResolveResult result; IType expectedType = null; Conversion conversion = null; if (csharpTreeView.SelectedNode != null) { var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag; CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile); result = resolver.Resolve(selectedNode); // CSharpAstResolver.Resolve() never returns null Expression expr = selectedNode as Expression; if (expr != null) { expectedType = resolver.GetExpectedType(expr); conversion = resolver.GetConversion(expr); } } else { TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart); result = ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location); if (result == null) { MessageBox.Show("Could not find a resolvable node at the caret location."); return; } } using (var dlg = new SemanticTreeDialog()) { dlg.AddRoot("Resolve() = ", result); if (expectedType != null) { dlg.AddRoot("GetExpectedType() = ", expectedType); } if (conversion != null) { dlg.AddRoot("GetConversion() = ", conversion); } dlg.ShowDialog(); } }
private void TraverseNodes(AstNode node) { foreach (var child in node.Children) { if (Options.MiscCompressing && child is PrimitiveExpression) { var primitiveExpression = (PrimitiveExpression)child; if (IsIntegerNumber(primitiveExpression.Value)) { string str = primitiveExpression.Value.ToString(); long number; if (long.TryParse(str, out number)) { string hex = "0x" + number.ToString("X"); primitiveExpression.SetValue(primitiveExpression.Value, str.Length < hex.Length ? str : hex); } } } else if (Options.MiscCompressing && child is CSharpModifierToken) { // private int a => int a var modifier = ((CSharpModifierToken)child).Modifier; if (modifier.HasFlag(Modifiers.Private) && (modifier & ~Modifiers.Private) == 0) { child.Remove(); } else { modifier &= ~Modifiers.Private; } } else if (Options.NamespacesRemoving && child is NamespaceDeclaration) { var childrenToRemove = child.Children.TakeWhile(c => !(c is CSharpTokenNode && c.Role.ToString() == "{")); foreach (AstNode childToRemove in childrenToRemove) { childToRemove.Remove(); } if (child.Children.Count() > 0) { child.Children.First().Remove(); } if (child.Children.Count() > 0) { child.Children.Last().Remove(); } var namespaceChildrens = child.Children; var parent = child.Parent; foreach (var c in parent.Children) { if (c == child) { foreach (var nsChildren in namespaceChildrens) { parent.InsertChildAfter(c, nsChildren.Clone(), new Role <AstNode>(nsChildren.Role.ToString())); } c.Remove(); break; } } foreach (AstNode c in parent.Children) { TraverseNodes(c); } } else if (Options.MiscCompressing && child is VariableDeclarationStatement) { // List<byte> a = new List<byte>() => var a = new List<byte>() // var a = new b() => b a = new b() var varDecExpr = (VariableDeclarationStatement)child; if (!varDecExpr.Modifiers.HasFlag(Modifiers.Const)) { var type = varDecExpr.Type.ToString().Replace(" ", ""); if (type == VarId) { // Resolving expression type. CompileAndResolve(); var expectedType = _resolver.GetExpectedType(varDecExpr.Variables.Single().Initializer); if (expectedType.Namespace != "System.Collections.Generic") { string typeStr = expectedType.Name; bool replace = NamesGenerator.CSharpTypeSynonyms.TryGetValue(typeStr, out typeStr); if (!replace) { typeStr = expectedType.Name; } if (typeStr.Length <= VarId.Length) { replace = true; } else { replace = false; } if (replace) { if (expectedType.Namespace == "System") { varDecExpr.Type = new PrimitiveType(typeStr); } else { varDecExpr.Type = new SimpleType(typeStr); } } } } else { if (varDecExpr.Variables.Count == 1) { string typeStr; var typeStrWithoutNamespaces = varDecExpr.Type.ToString(); typeStrWithoutNamespaces = typeStrWithoutNamespaces.Substring(typeStrWithoutNamespaces.LastIndexOf('.') + 1); NamesGenerator.CSharpTypeSynonyms.TryGetValue(typeStrWithoutNamespaces, out typeStr); if (typeStr == null) { typeStr = varDecExpr.Type.ToString(); } var initializer = varDecExpr.Variables.Single().Initializer; if (((typeStr == "string" || typeStr == "char" || typeStr == "bool") && initializer != NullReferenceExpression.Null) || initializer is ObjectCreateExpression) { if (VarId.Length < type.Length) { varDecExpr.Type = new SimpleType(VarId); } } } } } foreach (var variable in varDecExpr.Variables) { TraverseNodes(child); } } else if (child is EmptyStatement) { // { ; ; } => {} if (!(child.Parent is BlockStatement)) { if (Options.Unsafe) { node.Remove(); } } else { child.Remove(); } } else { string role = child.Role.ToString(); if (Options.MiscCompressing && child is BlockStatement && role != "Body" && role != "TryBlock") { // if (a) { b; } => if (a) b; var childrenCount = child.Children.Count(c => !(c is NewLineNode)); if (childrenCount == 3) { child.ReplaceWith(child.Children.Skip(1).FirstOrDefault(c => !(c is NewLineNode))); } else if (childrenCount < 3) { if (!(child.Parent is BlockStatement)) { if (Options.Unsafe) { node.Remove(); } else { child.ReplaceWith(new EmptyStatement()); } } else { child.Remove(); } } } else if (Options.Unsafe && child is BinaryOperatorExpression) { // if (a == true) => if (a) // if (a == false) => if (!a) var binaryExpression = (BinaryOperatorExpression)child; var primitiveExpression = binaryExpression.Left as PrimitiveExpression; var expression = binaryExpression.Right; if (primitiveExpression == null) { primitiveExpression = binaryExpression.Right as PrimitiveExpression; expression = binaryExpression.Left; } if (primitiveExpression != null && primitiveExpression.Value is bool) { var boolean = (bool)primitiveExpression.Value; expression.Remove(); if (boolean) { child.ReplaceWith(expression); } else { child.ReplaceWith(new UnaryOperatorExpression(UnaryOperatorType.Not, expression)); } } } TraverseNodes(child); } } }
public IType GetExpectedType(Expression expression) { return(resolver.GetExpectedType(expression, cancellationToken)); }