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));
}
