Esempio n. 1
0
            void CheckSegments(IList <IFormatStringSegment> segments, TextLocation formatStart, IList <Expression> formatArguments, AstNode anchor)
            {
                int argumentCount = formatArguments.Count;

                foreach (var segment in segments)
                {
                    var errors     = segment.Errors.ToList();
                    var formatItem = segment as FormatItem;
                    if (formatItem != null)
                    {
                        var segmentEnd   = new TextLocation(formatStart.Line, formatStart.Column + segment.EndLocation + 1);
                        var segmentStart = new TextLocation(formatStart.Line, formatStart.Column + segment.StartLocation + 1);
                        if (formatItem.Index >= argumentCount)
                        {
                            var outOfBounds = context.TranslateString("The index '{0}' is out of bounds of the passed arguments");
                            AddIssue(new CodeIssue(segmentStart, segmentEnd, string.Format(outOfBounds, formatItem.Index)));
                        }
                        if (formatItem.HasErrors)
                        {
                            var    errorMessage = string.Join(Environment.NewLine, errors.Select(error => error.Message).ToArray());
                            string messageFormat;
                            if (errors.Count > 1)
                            {
                                messageFormat = context.TranslateString("Multiple:\n{0}");
                            }
                            else
                            {
                                messageFormat = context.TranslateString("{0}");
                            }
                            AddIssue(new CodeIssue(segmentStart, segmentEnd, string.Format(messageFormat, errorMessage)));
                        }
                    }
                    else if (segment.HasErrors)
                    {
                        foreach (var error in errors)
                        {
                            var errorStart = new TextLocation(formatStart.Line, formatStart.Column + error.StartLocation + 1);
                            var errorEnd   = new TextLocation(formatStart.Line, formatStart.Column + error.EndLocation + 1);
                            AddIssue(new CodeIssue(errorStart, errorEnd, error.Message));
                        }
                    }
                }
            }
        protected override IEnumerable <CodeAction> GetFixes(BaseRefactoringContext context, Node env,
                                                             string variableName)
        {
            var containingStatement = env.ContainingStatement;

            // we don't give a fix for these cases since the general fix may not work
            // lambda in while/do-while/for condition
            if (containingStatement is WhileStatement || containingStatement is DoWhileStatement ||
                containingStatement is ForStatement)
            {
                yield break;
            }
            // lambda in for initializer/iterator
            if (containingStatement.Parent is ForStatement &&
                ((ForStatement)containingStatement.Parent).EmbeddedStatement != containingStatement)
            {
                yield break;
            }

            Action <Script> action = script =>
            {
                var newName = LocalVariableNamePicker.PickSafeName(
                    containingStatement.GetParent <EntityDeclaration> (),
                    Enumerable.Range(1, 100).Select(i => variableName + i));

                var variableDecl = new VariableDeclarationStatement(new SimpleType("var"), newName,
                                                                    new IdentifierExpression(variableName));

                if (containingStatement.Parent is BlockStatement || containingStatement.Parent is SwitchSection)
                {
                    script.InsertBefore(containingStatement, variableDecl);
                }
                else
                {
                    var offset = script.GetCurrentOffset(containingStatement.StartLocation);
                    script.InsertBefore(containingStatement, variableDecl);
                    script.InsertText(offset, "{");
                    script.InsertText(script.GetCurrentOffset(containingStatement.EndLocation), "}");
                    script.FormatText(containingStatement.Parent);
                }

                var textNodes = new List <AstNode> ();
                textNodes.Add(variableDecl.Variables.First().NameToken);

                foreach (var reference in env.GetAllReferences())
                {
                    var identifier = new IdentifierExpression(newName);
                    script.Replace(reference.AstNode, identifier);
                    textNodes.Add(identifier);
                }
                script.Link(textNodes.ToArray());
            };

            yield return(new CodeAction(context.TranslateString("Copy to local variable"), action, env.AstNode));
        }
Esempio n. 3
0
            CodeAction GetAction(BaseRefactoringContext context, Expression targetExpression,
                                 IMember member)
            {
                var    builder     = context.CreateTypeSystemAstBuilder(targetExpression);
                var    newType     = builder.ConvertType(member.DeclaringType);
                string description = string.Format("{0} '{1}'", context.TranslateString("Use base qualifier"), newType.ToString());

                return(new CodeAction(description, script => {
                    script.Replace(targetExpression, newType);
                }, targetExpression));
            }
            public override void VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
            {
                base.VisitVariableDeclarationStatement(variableDeclarationStatement);

                var rootNode = variableDeclarationStatement.Parent as BlockStatement;

                if (rootNode == null)
                {
                    // We are somewhere weird, like a the ResourceAquisition of a using statement
                    return;
                }

                // TODO: Handle declarations with more than one variable?
                if (variableDeclarationStatement.Variables.Count > 1)
                {
                    return;
                }

                var variableInitializer = variableDeclarationStatement.Variables.First();
                var identifiers         = GetIdentifiers(rootNode.Descendants, variableInitializer.Name).ToList();

                if (identifiers.Count == 0)
                {
                    // variable is not used
                    return;
                }

                if (!CheckForInvocations(variableInitializer.Initializer))
                {
                    return;
                }

                AstNode deepestCommonAncestor = GetDeepestCommonAncestor(rootNode, identifiers);
                var     path = GetPath(rootNode, deepestCommonAncestor);

                // The node that will follow the moved declaration statement
                AstNode anchorNode = GetInitialAnchorNode(rootNode, identifiers, path);

                // Restrict path to only those where the initializer has not changed
                var pathToCheck = path.Skip(1).ToList();
                var firstInitializerChangeNode = GetFirstInitializerChange(variableDeclarationStatement, pathToCheck, variableInitializer.Initializer);

                if (firstInitializerChangeNode != null)
                {
                    // The node changing the initializer expression may not be on the path
                    // to the actual usages of the variable, so we need to merge the paths
                    // so we get the part of the paths that are common between them
                    var pathToChange       = GetPath(rootNode, firstInitializerChangeNode);
                    var deepestCommonIndex = GetLowestCommonAncestorIndex(path, pathToChange);
                    anchorNode = pathToChange [deepestCommonIndex + 1];
                    path       = pathToChange.Take(deepestCommonIndex).ToList();
                }

                // Restrict to locations outside of blacklisted node types
                var firstBlackListedNode = path.FirstOrDefault(node => moveTargetBlacklist.Contains(node.GetType()));

                if (firstBlackListedNode != null)
                {
                    path       = GetPath(rootNode, firstBlackListedNode.Parent);
                    anchorNode = firstBlackListedNode;
                }

                anchorNode = GetInsertionPoint(anchorNode);

                if (anchorNode != null && anchorNode != rootNode && anchorNode.Parent != rootNode)
                {
                    AddIssue(new CodeIssue(variableDeclarationStatement, context.TranslateString("Variable could be moved to a nested scope"),
                                           GetActions(variableDeclarationStatement, (Statement)anchorNode)));
                }
            }
Esempio n. 5
0
            public override void VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression)
            {
                base.VisitObjectCreateExpression(objectCreateExpression);

                Expression paramNode;
                Expression altParamNode;
                bool       canAddParameterName;

                if (!CheckExceptionType(objectCreateExpression, out paramNode, out altParamNode, out canAddParameterName))
                {
                    return;
                }

                var paramName = GetArgumentParameterName(paramNode);

                if (paramName == null)
                {
                    return;
                }
                var validNames = GetValidParameterNames(objectCreateExpression);

                if (!validNames.Contains(paramName))
                {
                    // Case 1: Parameter name is swapped
                    var altParamName = GetArgumentParameterName(altParamNode);
                    if (altParamName != null && validNames.Contains(altParamName))
                    {
                        AddIssue(new CodeIssue(
                                     paramNode,
                                     string.Format(context.TranslateString("The parameter '{0}' can't be resolved"), paramName),
                                     context.TranslateString("Swap parameter."),
                                     script => {
                            var newAltNode = paramNode.Clone();
                            script.Replace(paramNode, altParamNode.Clone());
                            script.Replace(altParamNode, newAltNode);
                        }
                                     ));
                        AddIssue(new CodeIssue(
                                     altParamNode,
                                     context.TranslateString("The parameter name is on the wrong argument."),
                                     context.TranslateString("Swap parameter."),
                                     script => {
                            var newAltNode = paramNode.Clone();
                            script.Replace(paramNode, altParamNode.Clone());
                            script.Replace(altParamNode, newAltNode);
                        }
                                     ));
                        return;
                    }
                    var guessName = GuessParameterName(objectCreateExpression, validNames);
                    if (guessName != null)
                    {
                        var actions = new List <CodeAction>();

                        actions.Add(new CodeAction(
                                        string.Format(context.TranslateString("Replace with '\"{0}\"'."), guessName),
                                        script => {
                            script.Replace(paramNode, new PrimitiveExpression(guessName));
                        }, paramNode
                                        ));

                        if (canAddParameterName)
                        {
                            actions.Add(new CodeAction(
                                            string.Format(context.TranslateString("Add '\"{0}\"' parameter."), guessName),
                                            script => {
                                var oce = (ObjectCreateExpression)objectCreateExpression.Clone();
                                oce.Arguments.Clear();
                                oce.Arguments.Add(new PrimitiveExpression(guessName));
                                oce.Arguments.Add(objectCreateExpression.Arguments.First().Clone());
                                script.Replace(objectCreateExpression, oce);
                            }, paramNode
                                            ));
                        }

                        AddIssue(new CodeIssue(
                                     paramNode,
                                     string.Format(context.TranslateString("The parameter '{0}' can't be resolved"), paramName),
                                     actions
                                     ));
                        return;
                    }

                    // General case: mark only
                    AddIssue(new CodeIssue(
                                 paramNode,
                                 string.Format(context.TranslateString("The parameter '{0}' can't be resolved"), paramName)
                                 ));
                }
            }
Esempio n. 6
0
        static CodeAction HandleNegatedCase(BaseRefactoringContext ctx, IfElseStatement ifElseStatement, Match match, out IsExpression isExpression, out int foundCastCount)
        {
            foundCastCount = 0;
            var outerIs = match.Get <Expression>("isExpression").Single();

            isExpression = AlUtil.GetInnerMostExpression(outerIs) as IsExpression;
            var obj        = AlUtil.GetInnerMostExpression(isExpression.Expression);
            var castToType = isExpression.Type;

            var cast = new Choice {
                PatternHelper.OptionalParentheses(PatternHelper.OptionalParentheses(obj.Clone()).CastTo(castToType.Clone())),
                PatternHelper.OptionalParentheses(PatternHelper.OptionalParentheses(obj.Clone()).CastAs(castToType.Clone()))
            };

            var rr = ctx.Resolve(castToType);

            if (rr == null || rr.IsError || rr.Type.IsReferenceType == false)
            {
                return(null);
            }
            var foundCasts = ifElseStatement.GetParent <BlockStatement>().DescendantNodes(n => n.StartLocation >= ifElseStatement.StartLocation && !cast.IsMatch(n)).Where(n => cast.IsMatch(n)).ToList();

            foundCastCount = foundCasts.Count;

            return(new CodeAction(ctx.TranslateString("Use 'as' and check for null"), script => {
                var varName = ctx.GetNameProposal(CreateMethodDeclarationAction.GuessNameFromType(rr.Type), ifElseStatement.StartLocation);
                var varDec = new VariableDeclarationStatement(new PrimitiveType("var"), varName, new AsExpression(obj.Clone(), castToType.Clone()));
                var binaryOperatorIdentifier = new IdentifierExpression(varName);
                var binaryOperatorExpression = new BinaryOperatorExpression(binaryOperatorIdentifier, BinaryOperatorType.Equality, new NullReferenceExpression());
                var linkedNodes = new List <AstNode>();
                linkedNodes.Add(varDec.Variables.First().NameToken);
                linkedNodes.Add(binaryOperatorIdentifier);
                if (IsEmbeddedStatement(ifElseStatement))
                {
                    var block = new BlockStatement();
                    block.Add(varDec);
                    var newIf = (IfElseStatement)ifElseStatement.Clone();
                    newIf.Condition = binaryOperatorExpression;
                    foreach (var node in newIf.DescendantNodesAndSelf(n => !cast.IsMatch(n)).Where(n => cast.IsMatch(n)))
                    {
                        var id = new IdentifierExpression(varName);
                        linkedNodes.Add(id);
                        node.ReplaceWith(id);
                    }
                    block.Add(newIf);
                    script.Replace(ifElseStatement, block);
                }
                else
                {
                    script.InsertBefore(ifElseStatement, varDec);
                    script.Replace(ifElseStatement.Condition, binaryOperatorExpression);
                    foreach (var c in foundCasts)
                    {
                        var id = new IdentifierExpression(varName);
                        linkedNodes.Add(id);
                        script.Replace(c, id);
                    }
                }
                script.Link(linkedNodes);
            }, isExpression.IsToken));
        }
Esempio n. 7
0
 public GatherVisitor(BaseRefactoringContext context, SyntaxTree unit,
                      AccessToClosureIssue qualifierDirectiveEvidentIssueProvider)
     : base(context, qualifierDirectiveEvidentIssueProvider)
 {
     this.title = context.TranslateString(qualifierDirectiveEvidentIssueProvider.Title);
 }
Esempio n. 8
0
        public string GetErrorMessage(BaseRefactoringContext ctx, string name, out IList <string> suggestedNames)
        {
            suggestedNames = new List <string>();
            string id = name;

            string errorMessage = null;

            bool   missingRequiredPrefix = false;
            bool   missingRequiredSuffix = false;
            string requiredPrefix        = null;
            string allowedPrefix         = null;
            string suffix = null;

            if (AllowedPrefixes != null && AllowedPrefixes.Length > 0)
            {
                allowedPrefix = AllowedPrefixes.FirstOrDefault(p => id.StartsWith(p, StringComparison.Ordinal));
                if (allowedPrefix != null)
                {
                    id = id.Substring(allowedPrefix.Length);
                }
            }

            if (RequiredPrefixes != null && RequiredPrefixes.Length > 0)
            {
                requiredPrefix = RequiredPrefixes.FirstOrDefault(p => id.StartsWith(p, StringComparison.Ordinal));
                if (requiredPrefix == null)
                {
                    errorMessage          = string.Format(ctx.TranslateString("Name should have prefix '{0}'. (Rule '{1}')."), RequiredPrefixes [0], Name);
                    missingRequiredPrefix = true;
                }
                else
                {
                    id = id.Substring(requiredPrefix.Length);
                }
            }
            else if (ForbiddenPrefixes != null && ForbiddenPrefixes.Length > 0)
            {
                requiredPrefix = ForbiddenPrefixes.FirstOrDefault(p => id.StartsWith(p, StringComparison.Ordinal));
                if (requiredPrefix != null)
                {
                    errorMessage = string.Format(ctx.TranslateString("Name has forbidden prefix '{0}'. (Rule '{1}')"), requiredPrefix, Name);
                    id           = id.Substring(requiredPrefix.Length);
                }
            }

            if (RequiredSuffixes != null && RequiredSuffixes.Length > 0)
            {
                suffix = RequiredSuffixes.FirstOrDefault(s => id.EndsWith(s, StringComparison.Ordinal));
                if (suffix == null)
                {
                    errorMessage          = string.Format(ctx.TranslateString("Name should have suffix '{0}'. (Rule '{1}')"), RequiredSuffixes [0], Name);
                    missingRequiredSuffix = true;
                }
                else
                {
                    id = id.Substring(0, id.Length - suffix.Length);
                }
            }
            else if (ForbiddenSuffixes != null && ForbiddenSuffixes.Length > 0)
            {
                suffix = ForbiddenSuffixes.FirstOrDefault(p => id.EndsWith(p, StringComparison.Ordinal));
                if (suffix != null)
                {
                    errorMessage = string.Format(ctx.TranslateString("Name has forbidden suffix '{0}'. (Rule '{1}')"), suffix, Name);
                    id           = id.Substring(0, id.Length - suffix.Length);
                }
            }

            switch (NamingStyle)
            {
            case NamingStyle.AllLower:
                if (id.Any(ch => char.IsLetter(ch) && char.IsUpper(ch)))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' contains upper case letters. (Rule '{1}')"), name, Name);
                    suggestedNames.Add(LowerCaseIdentifier(WordParser.BreakWords(id)));
                }
                else
                {
                    suggestedNames.Add(id);
                }
                break;

            case NamingStyle.AllUpper:
                if (id.Any(ch => char.IsLetter(ch) && char.IsLower(ch)))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' contains lower case letters. (Rule '{1}')"), name, Name);
                    suggestedNames.Add(UpperCaseIdentifier(WordParser.BreakWords(id)));
                }
                else
                {
                    suggestedNames.Add(id);
                }
                break;

            case NamingStyle.CamelCase:
                if (id.Length > 0 && !char.IsLower(id [0]))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should start with a lower case letter. (Rule '{1}')"), name, Name);
                }
                else if (!CheckUnderscore(id, UnderscoreHandling.Forbid))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should not separate words with an underscore. (Rule '{1}')"), name, Name);
                }
                else
                {
                    suggestedNames.Add(id);
                    break;
                }
                suggestedNames.Add(CamelCaseIdentifier(id));
                break;

            case NamingStyle.CamelCaseWithLowerLetterUnderscore:
                if (id.Length > 0 && !char.IsLower(id [0]))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should start with a lower case letter. (Rule '{1}')"), name, Name);
                }
                else if (!CheckUnderscore(id, UnderscoreHandling.AllowWithLowerStartingLetter))
                {
                    errorMessage = string.Format(ctx.TranslateString("after '_' a lower letter should follow. (Rule '{0}')"), Name);
                }
                else
                {
                    suggestedNames.Add(id);
                    break;
                }
                suggestedNames.Add(CamelCaseWithLowerLetterUnderscore(id));
                break;

            case NamingStyle.CamelCaseWithUpperLetterUnderscore:
                if (id.Length > 0 && !char.IsLower(id [0]))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should start with a lower case letter. (Rule '{1}')"), name, Name);
                }
                else if (!CheckUnderscore(id, UnderscoreHandling.AllowWithUpperStartingLetter))
                {
                    errorMessage = string.Format(ctx.TranslateString("after '_' an upper letter should follow. (Rule '{0}')"), Name);
                }
                else
                {
                    suggestedNames.Add(id);
                    break;
                }
                suggestedNames.Add(CamelCaseWithUpperLetterUnderscore(id));
                break;

            case NamingStyle.PascalCase:
                if (id.Length > 0 && !char.IsUpper(id [0]))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should start with an upper case letter. (Rule '{1}')"), name, Name);
                }
                else if (!CheckUnderscore(id, UnderscoreHandling.Forbid))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should not separate words with an underscore. (Rule '{1}')"), name, Name);
                }
                else
                {
                    suggestedNames.Add(id);
                    break;
                }
                suggestedNames.Add(PascalCaseIdentifier(id));
                break;

            case NamingStyle.PascalCaseWithLowerLetterUnderscore:
                if (id.Length > 0 && !char.IsUpper(id [0]))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should start with an upper case letter. (Rule '{1}')"), name, Name);
                }
                else if (!CheckUnderscore(id, UnderscoreHandling.AllowWithLowerStartingLetter))
                {
                    errorMessage = string.Format(ctx.TranslateString("after '_' a lower letter should follow. (Rule '{0}')"), Name);
                }
                else
                {
                    suggestedNames.Add(id);
                    break;
                }
                suggestedNames.Add(PascalCaseWithLowerLetterUnderscore(id));
                break;

            case NamingStyle.PascalCaseWithUpperLetterUnderscore:
                if (id.Length > 0 && !char.IsUpper(id [0]))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should start with an upper case letter. (Rule '{1}')"), name, Name);
                }
                else if (!CheckUnderscore(id, UnderscoreHandling.AllowWithUpperStartingLetter))
                {
                    errorMessage = string.Format(ctx.TranslateString("after '_' an upper letter should follow. (Rule '{0}')"), Name);
                }
                else
                {
                    suggestedNames.Add(id);
                    break;
                }
                suggestedNames.Add(PascalCaseWithUpperLetterUnderscore(id));
                break;

            case NamingStyle.FirstUpper:
                if (id.Length > 0 && !char.IsUpper(id [0]))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' should start with an upper case letter. (Rule '{1}')"), name, Name);
                }
                else if (id.Take(1).Any(ch => char.IsLetter(ch) && char.IsUpper(ch)))
                {
                    errorMessage = string.Format(ctx.TranslateString("'{0}' contains an upper case letter after the first. (Rule '{1}')"), name, Name);
                }
                else
                {
                    suggestedNames.Add(id);
                    break;
                }
                suggestedNames.Add(FirstUpperIdentifier(WordParser.BreakWords(id)));
                break;
            }

            if (requiredPrefix != null)
            {
                for (int i = 0; i < suggestedNames.Count; i++)
                {
                    suggestedNames [i] = requiredPrefix + suggestedNames [i];
                }
            }
            else if (allowedPrefix != null)
            {
                int count = suggestedNames.Count;
                for (int i = 0; i < count; i++)
                {
                    suggestedNames.Add(suggestedNames [i]);
                    suggestedNames [i] = allowedPrefix + suggestedNames [i];
                }
            }
            else if (missingRequiredPrefix)
            {
                for (int i = 0; i < suggestedNames.Count; i++)
                {
                    var  n     = suggestedNames [i];
                    bool first = true;
                    foreach (var p in RequiredPrefixes)
                    {
                        if (first)
                        {
                            first = false;
                            suggestedNames [i] = p + n;
                        }
                        else
                        {
                            suggestedNames.Add(p + n);
                        }
                    }
                }
            }

            if (suffix != null)
            {
                for (int i = 0; i < suggestedNames.Count; i++)
                {
                    suggestedNames [i] = ApplySuffix(suggestedNames [i], suffix);
                }
            }
            else if (missingRequiredSuffix)
            {
                for (int i = 0; i < suggestedNames.Count; i++)
                {
                    var  n     = suggestedNames [i];
                    bool first = true;
                    foreach (var s in RequiredSuffixes)
                    {
                        if (first)
                        {
                            first = false;
                            suggestedNames [i] = ApplySuffix(n, s);
                        }
                        else
                        {
                            suggestedNames.Add(ApplySuffix(n, s));
                        }
                    }
                }
            }

            return(errorMessage
                   // should never happen.
                   ?? "no known errors.");
        }