public override ProblemCollection Check(Member member) { Method method = member as Method; MetadataCollection <Instruction> enumerator = method.Instructions; methodName = method.Name.ToString(); StatementCollection stmt = method.Body.Statements; try { problemyn = false; VisitStatements(stmt); if (problemyn) { Resolution resolu = GetResolution(new string[] { method.ToString() + errorMessage }); Problems.Add(new Problem(resolu)); } } catch (Exception e) { Console.WriteLine(e); } return(Problems); }
public override void VisitReturn(ReturnNode returnInstruction) { if (_problemRound && IsSqlGeneratingFunction(_currentMember)) { if (returnInstruction.Expression != null && IsStringIsh(returnInstruction.Expression.Type) && !IsConst(returnInstruction.Expression) && !_dirty.IsSafe(returnInstruction.Expression)) { if (!_params.Contains(returnInstruction.Expression.UniqueKey) || _dirty.MarkedDirtyInsideMethod(returnInstruction.Expression)) //if the return IS a param, then it's also got to be marked dirty inside the method (like if you pass a SQL builder in, append stuff to it, and then return it back out) { Problems.Add(new Problem(this.GetResolution(returnInstruction.Expression.GetName(), _dirty.GetDirtyDetails(returnInstruction.Expression, returnInstruction, true)), returnInstruction.SourceContext)); } } var currentMethod = _currentMember as Method; foreach (var p in currentMethod.Parameters.Where(w => !IsTypeSafe(w.Type))) { //if it's been marked dirty (aside from being a param), DANGER! if (_dirty.MarkedDirtyInsideMethod(p)) { Problems.Add(new Problem(this.GetResolution(p.GetName(), _dirty.GetDirtyDetails(p, returnInstruction, false)), returnInstruction.SourceContext)); } } } base.VisitReturn(returnInstruction); }
public override ProblemCollection Check(ModuleNode node) { var assemblyNode = node as AssemblyNode; if (assemblyNode != null) { var assemblyAvailableResources = new HashSet <PropertyNode>(); var assemblyUsedResources = new HashSet <PropertyNode>(); _availableResources[assemblyNode] = assemblyAvailableResources; _usedResources[assemblyNode] = assemblyUsedResources; VisitAssembly(assemblyNode); IEnumerable <PropertyNode> unusedResources = from res in assemblyAvailableResources.Except(assemblyUsedResources) where !IsCommonResource(res) select res; foreach (PropertyNode item in unusedResources) { Problems.Add(new Problem(this.GetResolution(item.Name.Name, item.DeclaringType.FullName), item.UniqueKey.ToString())); } } return(Problems); }
private void CheckMethod(Method method) { if (method == null || method.FullName.Equals(RegionEndpointStaticConstructorName) || method.Instructions == null || method.Instructions.Count == 0) { return; } foreach (var instruction in method.Instructions) { var field = instruction.Value as Field; if (field != null && field.FullName.StartsWith(RegionEndpointFieldNamePrefix) && field.Type.FullName.Equals(RegionEndpointTypeName)) { var suppressionTarget = method.DeclaringType.FullName + ".#" + method.Name.Name + "(" + string.Join(",", method.Parameters.Select(p => p.Type.FullName).ToArray()) + ")"; Resolution resolution; if (field.FullName.EndsWith(USEast1EndpointName)) { resolution = GetResolution(suppressionTarget, field.FullName, "shouldn't usually", USEast1ResolutionMessage); } else { resolution = GetResolution(suppressionTarget, field.FullName, "should never", ""); } Problems.Add(new Problem(resolution)); } } }
public override ProblemCollection Check(Member member) { var method = member as Method; if (method == null) { // This rule only applies to fields. // Return a null ProblemCollection so no violations are reported for this member. return(null); } if (method.FullName.EndsWith(".Finalize")) { bool disposeFound = method.Instructions.Any(p => p.Value is Method && (p.Value as Method).FullName.EndsWith(".Dispose(System.Boolean)")); if (!disposeFound) { Resolution resolution = GetResolution(method); var problem = new Problem(resolution); Problems.Add(problem); } return(Problems); } return(Problems); }
private void AddProblem(SourceContext sourceContext, Identifier parameterName) { var resolution = GetResolution(parameterName.Name); var problem = new Problem(resolution, sourceContext, CheckId); Problems.Add(problem); }
public override ProblemCollection Check(TypeNode typeNode) { if (typeNode.Interfaces.Any()) { InterfaceNode foundServiceInterface = typeNode.Interfaces.First(i => i.FullName.EndsWith(".IBaseService")); if (foundServiceInterface != null) { bool foundUsage = false; TypeNode serviceManagerTypeNode = foundServiceInterface.DeclaringModule.Types.First(t => t.FullName.EndsWith(".ServiceManager")); if (serviceManagerTypeNode != null) { Member member = serviceManagerTypeNode.Members.First(t => t.FullName.EndsWith(".RegisterAllServices")); var method = member as Method; if (method != null) { foundUsage = method.Instructions.Any(opcode => opcode.Value != null && opcode.Value.ToString().Contains(typeNode.FullName + "(")); } } if (!foundUsage) { Resolution resolution = GetResolution(typeNode.FullName); var problem = new Problem(resolution); Problems.Add(problem); } } } return(Problems); }
public void CreateProblem(string text) { var newProblem = new CreateProblemContainer(SqliteDb.GetInstance(), text, true).Container; Problems.Add(newProblem); CurrentProblem = newProblem; }
public override ProblemCollection Check(TypeNode type) { if (type == null) { return(Problems); } if (!IsPresenterImplementation(type)) { return(Problems); } if (!type.Name.Name.EndsWith("Presenter", StringComparison.Ordinal)) { Problems.Add(new Problem( GetResolution(type.FullName)) { Certainty = 100, FixCategory = FixCategories.Breaking, MessageLevel = MessageLevel.Warning }); } return(Problems); }
public override ProblemCollection Check(Member member) { Field field = member as Field; if (field == null) { // This rule only applies to fields. // Return a null ProblemCollection so no violations are reported for this member. return(null); } string actualType = field.Type.FullName; if (actualType == "SamplesForCodeAnalysis.ILog") { if (!field.IsStatic) { Resolution resolution = GetResolution(field, actualType); Problem problem = new Problem(resolution); Problems.Add(problem); } } return(Problems); }
public override ProblemCollection Check(Member member) { Method method = member as Method; bool boolFoundConnectionOpened = false; bool boolFoundConnectionClosed = false; Instruction objInstr = null; if (method != null) { for (int i = 0; i < method.Instructions.Count; i++) { objInstr = method.Instructions[i]; if (objInstr.Value != null) { if (objInstr.Value.ToString().Contains("System.Data.SqlClient.SqlConnection")) { boolFoundConnectionOpened = true; } if (boolFoundConnectionOpened) { if (objInstr.Value.ToString().Contains("System.Data.Common.DbConnection.Close")) { boolFoundConnectionClosed = true; } } } } } if ((boolFoundConnectionOpened) && (boolFoundConnectionClosed == false)) { Resolution resolu = GetResolution(new string[] { method.ToString() }); Problems.Add(new Problem(resolu)); } return(Problems); }
/// <inheritdoc /> public override void VisitBinaryExpression(BinaryExpression binaryExpression) { var operand1 = binaryExpression.Operand1 as BinaryExpression; if (operand1 == null) { var isEqual = binaryExpression.NodeType == NodeType.Ceq; var isLessThan = binaryExpression.NodeType == NodeType.Clt; var isGreaterThan = binaryExpression.NodeType == NodeType.Cgt; if (isEqual || isLessThan || isGreaterThan) { if (IsCountAndZeroOperation(binaryExpression)) { Problems.Add(CreateProblem(binaryExpression)); } } } else { var isNotEqual = operand1.NodeType == NodeType.Ceq; var isLessThanEqual = operand1.NodeType == NodeType.Cgt; var isGreaterThanEqual = operand1.NodeType == NodeType.Clt; if (isNotEqual || isLessThanEqual || isGreaterThanEqual) { if (IsCountAndZeroOperation(operand1)) { Problems.Add(CreateProblem(binaryExpression)); } } } }
public void When(RegistrationFailed c) { foreach (var problem in c.Problems) { Problems.Add(problem); } }
private void CheckForLongMethod(Method method) { if (CreateMetrics().Calculate(method) > 10) { string[] resolutionParams = { method.FullName }; Problems.Add(new Problem(new Resolution("Method {0} is too long", resolutionParams))); } }
private void CheckParamsLength(Method method) { if (method.Parameters.Count > 3) { string[] resolutionParams = { method.FullName }; Problems.Add(new Problem(new Resolution("Method {0} has too many parameters", resolutionParams))); } }
private void CheckType(TypeNode type, Member member) { if (IsAssignableTo(type, MD5Type)) { var resolution = GetResolution(type, member.FullName); Problems.Add(new Problem(resolution)); } }
public override ProblemCollection Check(Member member) { if (member.IsControllerAction() && !member.HasActionMethodSelectorAttribute()) { Problems.Add(new Problem(this.GetResolution())); } return(Problems); }
public override ProblemCollection Check(Member member) { if (member.IsControllerAction() && member.Attributes.Any(a => a.Type.FullName == "CDS.Web.Authorization.SkipAuthorizeAttribute")) { Problems.Add(new Problem(this.GetResolution())); } return(Problems); }
public void AddProblem(string problem) { if (null == Problems) { Problems = new List <string>(); } Problems.Add(problem); }
private void CheckLongIdentifier(Identifier identifier) { if (identifier.Name.Length > 20 & !(identifier.Name.Contains("<") || (identifier.Name.Contains("$")))) { string[] resolutionParams = { identifier.Name }; Problems.Add(new Problem(new Resolution("Identifier {0} has more than 20 characters", resolutionParams), _currentNode)); } }
private void CheckStatic(TypeNode containerType, TypeNode typeOfStatic) { if (ImplementsILogger(typeOfStatic)) { var resolution = GetResolution(containerType, typeOfStatic, LoggerInterfaceFullName); Problems.Add(new Problem(resolution)); } }
private void CheckCollaborators(TypeNode type) { if (CreateCollabCount().Calculate(type) > 3) { string[] resolutionParams = { type.FullName }; Problems.Add(new Problem(new Resolution("Type {0} has more than 3 collaborators", resolutionParams), type)); } }
public void AddProblem(ProblemMetadata problemMetadata) { ArgumentUtility.CheckNotNull("problemMetadata", problemMetadata); var resolution = GetResolution(problemMetadata.ExpectedFragment, problemMetadata.GivenFragment); var problem = new Problem(resolution, problemMetadata.SourceContext, CheckId); Problems.Add(problem); }
public T RequiresComponent <T>(string expectedLocation = null) where T : Component { if (!Entity.TryGetComponentInChildren(out T component)) { Problems.Add(new MissingComponent(Entity, typeof(T), of, expectedLocation)); } return(component); }
private void CheckForLargeClass(TypeNode type) { if (MethodCount(type) > 8) { string[] resolutionParams = { type.FullName }; Problems.Add(new Problem(new Resolution("Type {0} has too many methods/properties", resolutionParams))); } }
public async Task <bool> LoadAsync() { if (string.IsNullOrEmpty(Path)) { return(false); } try { FileStream fs = new FileStream(Path, FileMode.Open, FileAccess.Read); byte[] data = new byte[fs.Length]; await fs.ReadAsync(data, 0, data.Length).ConfigureAwait(false); List <ProblemViewModel> ps = new List <ProblemViewModel>(); data = DocumentHelper.UnpackData(data); if (data == null) { return(false); } MemoryStream ms = new MemoryStream(data); while (ms.Position < ms.Length) { ProblemViewModel problem = null; Dispatcher.BeginInvoke((Action)(() => { problem = ProblemViewModel.CreateFromStream(ms); })).Wait(); if (problem == null) { return(false); } if (!await Task.Factory.StartNew(() => { if (problem == null || !problem.Load(ms)) { return(false); } return(true); }).ConfigureAwait(false)) { return(false); } ps.Add(problem); } ms.Close(); Dispatcher.BeginInvoke((Action)(() => { Problems.Clear(); foreach (var problem in ps) { Problems.Add(problem); } })); IsDirty = false; return(true); } catch (Exception) { return(false); } }
public override ProblemCollection Check(Member member) { if (member.NodeType == NodeType.Method && member.Name.Name == "Finalize") { Problems.Add(new Problem(GetResolution(member.DeclaringType.FullName), member)); } return(Problems); }
/// <inheritdoc /> public override void VisitAssignmentStatement(AssignmentStatement assignment) { base.VisitAssignmentStatement(assignment); if (IsDefaultValue(assignment.Target.Type, assignment.Source)) { Problems.Add(CreateProblem(assignment)); } }
public static TrafficProblem NewRoad(string reasonName) { TrafficProblem problem = new TrafficProblem(reasonName); Problems.Add(problem); Save(); return(problem); }
/// <inheritdoc /> public override ProblemCollection Check(TypeNode type) { if (type.IsAssignableTo(FrameworkTypes.Exception) && type.IsAbstract == false && RuleUtilities.IsSerializable(type) == false) { Problems.Add(new Problem(GetResolution(type.Name.Name))); } return(Problems); }