Esempio n. 1
0
        public void AddUsings(params string[] usings)
        {
            AddUsingAction action = new AddUsingAction(
                this,
                usings);

            this.ActionManager.RecordAction(action);

            //			UsingBlock b = UsingSection;
            //
            //			List<string> toAdd;
            //			if (b == null)
            //			{
            //				toAdd = new List<string>(usings);
            //			}
            //			else
            //			{
            //				toAdd = new List<string>();
            //				foreach (string u in usings)
            //				{
            //					if (!b.Exists(u))
            //					{
            //						toAdd.Add(u);
            //					}
            //				}
            //			}
            //
            //			if (this.Root != null)
            //			{
            //				using (Transaction t = Transaction.Create(this.Root))
            //				{
            //					if (b == null)
            //					{
            //						b = new UsingBlock();
            //						this.AddToBeginning(b);
            //					}
            //					foreach (string s in toAdd)
            //					{
            //						b.Add(s);
            //					}
            //				}
            //			}
            //			else
            //			{
            //				using (Redrawer r = new Redrawer(this.Root))
            //				{
            //					if (b == null)
            //					{
            //						b = new UsingBlock();
            //						this.Children.Prepend(b);
            //					}
            //					foreach (string s in usings)
            //					{
            //						b.Add(s);
            //					}
            //				}
            //			}
        }
Esempio n. 2
0
        public FixUsingsResponse FixUsings(Request request)
        {
            _fileName = request.FileName;
            string buffer = RemoveUsings(request.Buffer);

            buffer = SortUsings(buffer);
            buffer = AddLinqForQueryIfMissing(buffer);

            bool ambiguousResultsFound = false;
            bool usingsAdded           = true;

            while (usingsAdded)
            {
                var content = _bufferParser.ParsedContent(buffer, _fileName);
                var tree    = content.SyntaxTree;

                var resolver        = new CSharpAstResolver(content.Compilation, content.SyntaxTree, content.UnresolvedFile);
                var unresolvedNodes = GetAllUnresolvedNodes(tree, resolver).Select(nr => GetNodeToAddUsing(nr));
                usingsAdded    = false;
                request.Buffer = buffer;
                var outerContext = OmniSharpRefactoringContext.GetContext(_bufferParser, request);
                using (var script = new OmniSharpScript(outerContext, _config))
                {
                    foreach (var unresolvedNode in unresolvedNodes)
                    {
                        _logger.Info(unresolvedNode);

                        var requestForNode = CreateRequest(buffer, unresolvedNode);
                        var innerContext   = OmniSharpRefactoringContext.GetContext(_bufferParser, requestForNode);
                        var addUsingAction = new AddUsingAction();
                        var actions        = addUsingAction.GetActions(innerContext).Where(a => a.Description.StartsWith("using")).ToArray();

                        if (actions.Length == 1)
                        {
                            var a = actions[0];
                            _logger.Info("Adding " + a.Description);
                            a.Run(script);
                            usingsAdded = true;
                            break;
                        }
                        ambiguousResultsFound |= actions.Length > 1;
                    }
                }
                buffer = outerContext.Document.Text;
            }

            IEnumerable <QuickFix> ambiguous = Enumerable.Empty <QuickFix>();

            if (ambiguousResultsFound)
            {
                ambiguous = GetAmbiguousNodes(buffer, request.FileName);
            }
            return(new FixUsingsResponse(buffer, ambiguous));
        }
Esempio n. 3
0
        public void AddUsing(UsingDirective usingDirective)
        {
            AddUsingAction action = new AddUsingAction(this, usingDirective);

            this.ActionManager.RecordAction(action);
        }