protected static bool HidesMember(BaseRefactoringContext ctx, AstNode node, string variableName) { var typeDecl = node.GetParent <TypeDeclaration>(); if (typeDecl == null) { return(false); } var entityDecl = node.GetParent <EntityDeclaration>(); var memberResolveResult = ctx.Resolve(entityDecl) as MemberResolveResult; if (memberResolveResult == null) { return(false); } var typeResolveResult = ctx.Resolve(typeDecl) as TypeResolveResult; if (typeResolveResult == null) { return(false); } var sourceMember = memberResolveResult.Member; return(typeResolveResult.Type.GetMembers(m => m.Name == variableName).Any(m2 => IsAccessible(sourceMember, m2))); }
Func <Expression, bool> GetChecker(Expression expression, IList <IdentifierExpression> identifiers) { // TODO: This only works for simple cases. IList <IMember> members; IList <IVariable> locals; var identifierResolveResults = identifiers.Select(identifier => context.Resolve(identifier)).ToList(); SplitResolveResults(identifierResolveResults, out members, out locals); if (expression is InvocationExpression || expression is ObjectCreateExpression) { return(node => { if (node is InvocationExpression || node is ObjectCreateExpression) { // We don't know what these might do, so assume it will change the initializer return true; } var binaryOperator = node as BinaryOperatorExpression; if (binaryOperator != null) { var resolveResult = context.Resolve(binaryOperator) as OperatorResolveResult; if (resolveResult == null) { return false; } // Built-in operators are ok, user defined ones not so much return resolveResult.UserDefinedOperatorMethod != null; } return IsConflictingAssignment(node, identifiers, members, locals); }); } else if (expression is IdentifierExpression) { var initializerDependsOnMembers = identifierResolveResults.Any(result => result is MemberResolveResult); var initializerDependsOnReferenceType = identifierResolveResults.Any(result => result.Type.IsReferenceType == true); return(node => { if ((node is InvocationExpression || node is ObjectCreateExpression) && (initializerDependsOnMembers || initializerDependsOnReferenceType)) { // Anything can happen... return true; } var binaryOperator = node as BinaryOperatorExpression; if (binaryOperator != null) { var resolveResult = context.Resolve(binaryOperator) as OperatorResolveResult; if (resolveResult == null) { return false; } return resolveResult.UserDefinedOperatorMethod != null; } return IsConflictingAssignment(node, identifiers, members, locals); }); } return(node => false); }
void HandlePotentialWrite(Expression expression) { var variableResolveResult = ctx.Resolve(expression) as LocalResolveResult; if (variableResolveResult == null) { return; } variableWritten |= variableResolveResult.Equals(parameter); }
public override void VisitIdentifierExpression(IdentifierExpression identifierExpression) { if (!IsTargetOfInvocation(identifierExpression)) { var mgr = ctx.Resolve(identifierExpression) as MethodGroupResolveResult; if (mgr != null) { UsedMethods.AddRange(mgr.Methods); } } base.VisitIdentifierExpression(identifierExpression); }
public UsingInfo(AstNode node, BaseRefactoringContext context) { var importAndAlias = GetImportAndAlias(node); Node = node; Alias = importAndAlias.Item2; Name = importAndAlias.Item1.ToString(); IsAlias = Alias != null; ResolveResult rr; if (node.Ancestors.Contains(context.RootNode)) { rr = context.Resolve(importAndAlias.Item1); } else { // It's possible that we're looking at a new using that // isn't part of the AST. var resolver = new CSharpAstResolver(new CSharpResolver(context.Compilation), node); rr = resolver.Resolve(importAndAlias.Item1); } var nrr = rr as NamespaceResolveResult; HasTypesFromOtherAssemblies = nrr != null && nrr.Namespace.ContributingAssemblies.Any(a => !a.IsMainAssembly); IsSystem = HasTypesFromOtherAssemblies && (Name == "System" || Name.StartsWith("System.", StringComparison.Ordinal)); }
protected static bool HidesMember(BaseRefactoringContext ctx, AstNode node, string variableName) { var typeDecl = node.GetParent<TypeDeclaration>(); if (typeDecl == null) return false; var entityDecl = node.GetParent<EntityDeclaration>(); var memberResolveResult = ctx.Resolve(entityDecl) as MemberResolveResult; if (memberResolveResult == null) return false; var typeResolveResult = ctx.Resolve(typeDecl) as TypeResolveResult; if (typeResolveResult == null) return false; var sourceMember = memberResolveResult.Member; return typeResolveResult.Type.GetMembers(m => m.Name == variableName).Any(m2 => IsAccessible(sourceMember, m2)); }
private static void ExecuteScriptToFixStaticMethodIssue(Script script, BaseRefactoringContext context, AstNode methodDeclaration) { var clonedDeclaration = (MethodDeclaration)methodDeclaration.Clone(); clonedDeclaration.Modifiers |= Modifiers.Static; script.Replace(methodDeclaration, clonedDeclaration); var rr = context.Resolve(methodDeclaration) as MemberResolveResult; var method = (IMethod)rr.Member; //method.ImplementedInterfaceMembers.Any(m => methodGroupResolveResult.Methods.Contains((IMethod)m)); script.DoGlobalOperationOn(rr.Member, (fctx, fscript, fnode) => { DoStaticMethodGlobalOperation(fnode, fctx, rr, fscript); }); }
public override void VisitInvocationExpression(InvocationExpression invocationExpression) { base.VisitInvocationExpression(invocationExpression); if (!IsCallDependentOnCurrentInstance(invocationExpression)) { // Call within current class scope without 'this' or 'base' return; } var targetMethod = context.Resolve(invocationExpression) as InvocationResolveResult; if (targetMethod == null) { return; } if (targetMethod.IsVirtualCall) { AddIssue(invocationExpression, context.TranslateString("Constructors should not call virtual members")); } }
public override void VisitInvocationExpression(InvocationExpression invocationExpression) { base.VisitInvocationExpression(invocationExpression); // Speed up the inspector by discarding some invocations early var hasEligibleArgument = invocationExpression.Arguments.Any(argument => { var primitiveArg = argument as PrimitiveExpression; return(primitiveArg != null && primitiveArg.Value is string); }); if (!hasEligibleArgument) { return; } var invocationResolveResult = context.Resolve(invocationExpression) as CSharpInvocationResolveResult; if (invocationResolveResult == null) { return; } Expression formatArgument; IList <Expression> formatArguments; TextLocation formatStart; if (!FormatStringHelper.TryGetFormattingParameters(invocationResolveResult, invocationExpression, out formatArgument, out formatStart, out formatArguments, null)) { return; } var primitiveArgument = formatArgument as PrimitiveExpression; if (primitiveArgument == null || !(primitiveArgument.Value is string)) { return; } var format = (string)primitiveArgument.Value; var parsingResult = context.ParseFormatString(format); CheckSegments(parsingResult.Segments, formatStart, formatArguments, invocationExpression); }
public override void VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression) { var parameters = objectCreateExpression.Arguments; if (parameters.Count != 2) { return; } var firstParam = parameters.FirstOrNullObject() as PrimitiveExpression; var secondParam = parameters.LastOrNullObject() as PrimitiveExpression; if (firstParam == null || !(firstParam.Value is string) || secondParam == null || !(secondParam.Value is string)) { return; } var type = context.Resolve(objectCreateExpression.Type) as TypeResolveResult; if (type == null) { return; } var leftLength = (firstParam.Value as string).Length; var rightLength = (secondParam.Value as string).Length; Func <int, int, bool> func; if (!rules.TryGetValue(type.Type.FullName, out func)) { return; } if (!func(leftLength, rightLength)) { AddIssue(objectCreateExpression, context.TranslateString("The parameters are in the wrong order"), GetAction(objectCreateExpression, firstParam, secondParam)); } }