public string GetVerb(CodeFunction2 d) { List <CodeAttribute2> codeAttributes2 = d.Attributes.OfType <CodeAttribute2>().ToList(); var attrs = codeAttributes2.Select(attr => attr.Name).ToList(); var result = "Get"; if (attrs.Contains("HttpPost")) { result = "Post"; } if (attrs.Contains("HttpPut")) { result = "Put"; } if (attrs.Contains("HttpDelete")) { result = "Delete"; } if (attrs.Contains("HttpPatch")) { result = "Patch"; } if (attrs.Contains("HttpOption")) { result = "Option"; } return(result); }
public string GenerateCode(CodeFunction2 method) { CodeParameter2 param = method.Parameters.Item(1) as CodeParameter2; CodeClass2 containingClass = method.Parent as CodeClass2; string returnType = method.Type.AsFullName; string paramType = param.Type.AsFullName; string paramName = param.Name; string returnVariableName = string.Empty; string codeToInsert = string.Empty; bool convertingToEntity = CodeModelUtils.IsEntityClass(method.Type.CodeType); // If we are converting to an entity if (convertingToEntity) { returnVariableName = "entity"; codeToInsert += "// VO to entity conversion\n"; // Add code to create a new entity with the Factory.NewInstance() method codeToInsert += returnType + " " + returnVariableName + " = " + returnType + ".Factory.NewInstance();\n\n"; } else { returnVariableName = "valueObject"; codeToInsert += "// Entity to VO conversion\n\n"; // Add code to create a new VO with a new statement codeToInsert += returnType + " " + returnVariableName + " = new " + returnType + "();\n\n"; } ArrayList unmappedProperties = new ArrayList(); foreach (Property prop in m_properties) { if (prop.SourceProperty != null) { if (prop.IsNullableType) { codeToInsert += "if (" + paramName + "." +prop.Name + ".HasValue)\n{\n"; codeToInsert += returnVariableName + "." + prop.Name + " = " + paramName + "." + prop.SourceProperty.Name + ".Value;\n}\n"; } else { codeToInsert += returnVariableName + "." + prop.Name + " = " + paramName + "." + prop.SourceProperty.Name + ";\n"; } } else { unmappedProperties.Add(prop); } } foreach (Property unmappedProp in unmappedProperties) { codeToInsert += "// " + returnVariableName + "." + unmappedProp.Name + "\n"; } // Add the return statement codeToInsert += "\nreturn " + returnVariableName + ";\n\n"; return codeToInsert; }
public CodeMember(CodeElement2 element, CodeElement2 type, Language language) { this.element = element; this.TypeElement = type; this.language = language; this.Name = element.Name; this.RequiresSeparatorLine = element.Kind != vsCMElement.vsCMElementVariable; switch (element.Kind) { case vsCMElement.vsCMElementFunction: CodeFunction2 function = (CodeFunction2)element; MemberKind kind; switch (function.FunctionKind) { case vsCMFunction.vsCMFunctionConstructor: kind = MemberKind.Constructor; break; case vsCMFunction.vsCMFunctionDestructor: kind = MemberKind.Destructor; break; case vsCMFunction.vsCMFunctionOperator: kind = MemberKind.Operator; break; default: kind = MemberKind.Function; break; } this.Initialize( kind, function.Access, function.IsShared, function.OverrideKind, functionKind: function.FunctionKind, parameters: function.Parameters); break; case vsCMElement.vsCMElementProperty: CodeProperty2 property = (CodeProperty2)element; this.Initialize(MemberKind.Property, property.Access, property.IsShared, property.OverrideKind, parameters: property.Parameters); break; case vsCMElement.vsCMElementVariable: CodeVariable2 variable = (CodeVariable2)element; this.Initialize(MemberKind.Variable, variable.Access, variable.IsShared, constKind: variable.ConstKind); break; case vsCMElement.vsCMElementEvent: CodeEvent evt = (CodeEvent)element; this.Initialize(MemberKind.Event, evt.Access, evt.IsShared, evt.OverrideKind); break; default: throw new NotSupportedException("Unsupported element kind: " + element.Kind); } }
/// <summary> /// /// </summary> public CodeFunctionInfo(BaseInfo parent, CodeFunction2 method) : base(parent, method as CodeElement2) { // Can be null when an custom ActionResult has no ctor if (method == null) return; _item = method; Summary = string.Empty; _signature = method.Name; this.IsGeneric = method.IsGeneric; try { BuildComment(_item.DocComment); } catch (Exception) { } this.Access = ObjectFactory.Convert(this._item.Access); Parameters.ToList(); }
protected override void OnUnitTestProjectCreated(Project unitTestProject, CodeFunction2 sourceMethod) { if (unitTestProject == null) { throw new ArgumentNullException("unitTestProject"); } if (sourceMethod == null) { throw new ArgumentNullException("sourceMethod"); } // TODO: Remove references to "MSTestFramework" and "MSTestFramework.Universal" // Add package reference for xUnit.net TraceLogger.LogInfo("XunitSolutionManager.OnUnitTestProjectCreated: Adding reference to NuGet packages 'xunit' and 'xunit.runner.visualstudion' (version {0})", xunitPackageVersion); EnsureNuGetReference(unitTestProject, "xunit", xunitPackageVersion); EnsureNuGetReference(unitTestProject, "xunit.runner.visualstudio", visualStudioRunnerPackageVersion); // Remove any *.cs/*.vb files from the root of the project (i.e., Class1.cs/Class1.vb) foreach (var projectItem in unitTestProject.ProjectItems.AsEnumerable()) { var extension = Path.GetExtension(projectItem.Name).ToLowerInvariant(); if (extension == ".cs" || extension == ".vb") { TraceLogger.LogInfo("XunitSolutionManager.OnUnitTestProjectCreated: Removing project item {0}", projectItem.Name); projectItem.Delete(); } } }
protected override void OnUnitTestProjectCreated(Project unitTestProject, CodeFunction2 sourceMethod) { if (unitTestProject == null) throw new ArgumentNullException("unitTestProject"); if (sourceMethod == null) throw new ArgumentNullException("sourceMethod"); // TODO: Remove references to "MSTestFramework" and "MSTestFramework.Universal" // Add package reference for xUnit.net TraceLogger.LogInfo("XunitSolutionManager.OnUnitTestProjectCreated: Adding reference to NuGet packages 'xunit' and 'xunit.runner.visualstudion' (version {0})", xunitPackageVersion); EnsureNuGetReference(unitTestProject, "xunit", xunitPackageVersion); EnsureNuGetReference(unitTestProject, "xunit.runner.visualstudio", visualStudioRunnerPackageVersion); // Remove any *.cs/*.vb files from the root of the project (i.e., Class1.cs/Class1.vb) foreach (var projectItem in unitTestProject.ProjectItems.AsEnumerable()) { var extension = Path.GetExtension(projectItem.Name).ToLowerInvariant(); if (extension == ".cs" || extension == ".vb") { TraceLogger.LogInfo("XunitSolutionManager.OnUnitTestProjectCreated: Removing project item {0}", projectItem.Name); projectItem.Delete(); } } }
/// <summary> /// Finds the function code element. /// </summary> /// <param name="cc">The cc.</param> /// <param name="functionName">Name of the function.</param> /// <param name="arguments">The arguments.</param> /// <returns></returns> internal static CodeFunction2 FindFunctionCodeElement(CodeClass cc, string functionName, List <Argument> arguments) { foreach (CodeElement ce in cc.Members) { if (ce is CodeFunction2 && functionName == ce.Name) { CodeFunction2 cf = ce as CodeFunction2; if (arguments == null) { return(cf); } if (cf.Parameters.Count == arguments.Count) { // On regarde si les paramètres correspondent for (int i = 0; i < arguments.Count; i++) { CodeParameter param = (CodeParameter)cf.Parameters.Item(i + 1); if (param.Name != arguments[i].Name) { return(null); } } return(cf); } } } return(null); }
/// <summary> /// Adds missing access modifiers /// </summary> /// <param name="codeElement">The CodeElement to add missing access modifiers too. Includes children.</param> private void AddMissingAccessModifiers(CodeElement codeElement) { if (codeElement.Kind != vsCMElement.vsCMElementInterface && CodeElementBlockTypes.ContainsKey(codeElement.Kind)) { for (int i = 1; i <= codeElement.Children.Count; i++) { CodeElement element = codeElement.Children.Item(i) as CodeElement; if (element.Kind != vsCMElement.vsCMElementImportStmt && element.Kind != vsCMElement.vsCMElementInterface && CodeElementBlockTypes.ContainsKey(codeElement.Kind)) { // Get the element's access through reflection rather than a massive switch. vsCMAccess access = (vsCMAccess)CodeElementTypes[element.Kind].InvokeMember("Access", BindingFlags.GetProperty, null, element, null); if (element.Kind == vsCMElement.vsCMElementClass || element.Kind == vsCMElement.vsCMElementStruct) { AddMissingAccessModifiers(element); } EditPoint start; EditPoint end; string declaration; if (element.Kind == vsCMElement.vsCMElementFunction) { // method, constructor, or finalizer CodeFunction2 function = element as CodeFunction2; // Finalizers don't have access modifiers, neither do static constructors if (function.FunctionKind == vsCMFunction.vsCMFunctionDestructor || (function.FunctionKind == vsCMFunction.vsCMFunctionConstructor && function.IsShared)) { continue; } } if (element.Kind == vsCMElement.vsCMElementProperty || element.Kind == vsCMElement.vsCMElementVariable || element.Kind == vsCMElement.vsCMElementEvent) { CodeElements attributes = (CodeElements)CodeElementTypes[element.Kind].InvokeMember("Attributes", BindingFlags.GetProperty, null, element, null); start = attributes.Count > 0 ? element.GetEndPoint(vsCMPart.vsCMPartAttributesWithDelimiter).CreateEditPoint() : element.StartPoint.CreateEditPoint(); } else { start = element.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint(); } end = start.CreateEditPoint(); end.EndOfLine(); declaration = start.GetText(end); if (!declaration.StartsWith(CodeAccessKeywords[access]) && !declaration.StartsWith("partial")) { object[] args = new object[1]; args.SetValue(access, 0); CodeElementTypes[element.Kind].InvokeMember("Access", BindingFlags.SetProperty, null, element, args); } declaration = start.GetText(end); } } } }
/// <summary> /// Performs any preparatory tasks that have to be done after a new unit test project has been created. /// </summary> /// <param name="unitTestProject">The <see cref="Project"/> of the unit test project that has just been created.</param> /// <param name="sourceMethod">The <see cref="CodeFunction2"/> of the source method that is to be unit tested.</param> protected override void OnUnitTestProjectCreated(Project unitTestProject, CodeFunction2 sourceMethod) { if (unitTestProject == null) { throw new ArgumentNullException(nameof(unitTestProject)); } if (sourceMethod == null) { throw new ArgumentNullException(nameof(sourceMethod)); } TraceLogger.LogInfo("xUnitSolutionManager.OnUnitTestProjectCreated: Adding reference to NUnit assemblies through nuget."); base.OnUnitTestProjectCreated(unitTestProject, sourceMethod); this.EnsureNuGetReference(unitTestProject, "xunit", "2.4.1"); this.EnsureNuGetReference(unitTestProject, "xunit.runner.visualstudio", "2.4.1"); var vsp = unitTestProject.Object as VSProject2; var reference = vsp?.References.Find(GlobalConstants.MSTestAssemblyName); if (reference != null) { TraceLogger.LogInfo("xUnitSolutionManager.OnUnitTestProjectCreated: Removing reference to {0}", reference.Name); reference.Remove(); } }
/// <summary> /// Performs any preparatory tasks that have to be done after a new unit test project has been created. /// </summary> /// <param name="unitTestProject">The <see cref="Project"/> of the unit test project that has just been created.</param> /// <param name="sourceMethod">The <see cref="CodeFunction2"/> of the source method that is to be unit tested.</param> protected override void OnUnitTestProjectCreated(Project unitTestProject, CodeFunction2 sourceMethod) { if (unitTestProject == null) { throw new ArgumentNullException("unitTestProject"); } TraceLogger.LogInfo("MSTestv2SolutionManager.OnUnitTestProjectCreated: Adding reference to MSTestv2 assemblies through nuget."); base.OnUnitTestProjectCreated(unitTestProject, sourceMethod); this.EnsureNuGetReference(unitTestProject, "MSTest.TestAdapter", "1.1.18"); this.EnsureNuGetReference(unitTestProject, "MSTest.TestFramework", "1.1.18"); VSProject2 vsp = unitTestProject.Object as VSProject2; if (vsp != null) { Reference reference = vsp.References.Find(GlobalConstants.MSTestAssemblyName); if (reference != null) { TraceLogger.LogInfo("MSTestv2SolutionManager.OnUnitTestProjectCreated: Removing reference to {0}", reference.Name); reference.Remove(); } } }
public void initialize_constructor() { TextSelection selection = studio.ActiveDocument.Selection as TextSelection; CodeClass2 class_object = (CodeClass2)selection.ActivePoint.get_CodeElement(vsCMElement.vsCMElementClass); CodeFunction2 constructor = class_object.AddFunction(class_object.Name, vsCMFunction.vsCMFunctionConstructor, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic, 0) as CodeFunction2; string text = ""; foreach (CodeElement2 member in class_object.Members) { if (member.Kind == vsCMElement.vsCMElementVariable) { CodeVariable2 variable = member as CodeVariable2; CodeParameter2 parameter = constructor.AddParameter("new_" + variable.Name, variable.Type, -1) as CodeParameter2; text += "\r\n" + variable.Name + " = " + parameter.Name + ";"; } else if (member.Kind == vsCMElement.vsCMElementProperty) { var variable = member as CodeProperty; // CodeTypeRef new_type = CodeParameter2 parameter = constructor.AddParameter("new_" + variable.Name, variable.Type, -1) as CodeParameter2; text += "\r\n" + variable.Name + " = " + parameter.Name + ";"; } } EditPoint2 point = constructor.EndPoint.CreateEditPoint() as EditPoint2; point.LineUp(1); point.Insert(text); selection.MoveToPoint(constructor.StartPoint, false); selection.MoveToPoint(constructor.EndPoint, true); selection.SmartFormat(); selection.MoveToPoint(point, false); }
public PropertyMapperDialog(CodeFunction2 currentMethod, AddInSettings settings) { InitializeComponent(); m_currentMethod = currentMethod; this.KeyPreview = true; m_codeToInsert = string.Empty; m_addInSettings = settings; }
public PropertyMapperDialog(CodeFunction2 currentMethod, AddInSettings settings) { InitializeComponent(); m_currentMethod = currentMethod; this.KeyPreview = true; m_codeToInsert = string.Empty; m_addInSettings = settings; }
private string RenameMethod(CodeElement item) { //var sb = new StringBuilder(); if (item.Kind == vsCMElement.vsCMElementFunction) { //Debug.WriteLine("RenameMethod.FullName:" + item.FullName); if (methodWhiteList.Contains(item.Name) || interFaceFunction.Contains(item.Name) || item.Name.Contains(alien)) { Print("WriteListFunction :" + item.Name); return(""); } try { CodeFunction2 code3 = item as CodeFunction2; PrintFunction2Info(code3); if (code3.OverrideKind == vsCMOverrideKind.vsCMOverrideKindOverride || code3.OverrideKind == vsCMOverrideKind.vsCMOverrideKindNew || code3.OverrideKind == vsCMOverrideKind.vsCMOverrideKindAbstract || code3.OverrideKind == vsCMOverrideKind.vsCMOverrideKindVirtual) { PrintDetial("SpecialFunction :" + item.Name); return(""); } if (code3.IsShared) { PrintDetial("StaticFunction :" + item.Name); return(""); } if (item.Name.Contains(stringGlobal)) { PrintDetial("GlobalFunction :" + item.Name); return(""); } CodeElement2 code2 = item as CodeElement2; var one = nameCounter++; var alien2 = alien + nameCounter++; var three = nameCounter++; PrintDetial("RenameFunction :" + item.Name); var randomOne = GetRandomName(3, 5, useUpper: true); var randomThree = GetRandomName(3, 5, useUpper: true); var replacement = string.Format("{0}{1}{2}{3}{4}", randomOne, one, item.Name.Insert(item.Name.Length / 2, alien2), randomThree, three); code2.RenameSymbol(replacement); //sb += (" " + code.Name + " " + code.IsCodeType + " " + code.Kind + "\n"); } catch (Exception ex) { //except += " error: " + ex.Message + "\n" + item.Name; CodeFunction2 code3 = item as CodeFunction2; PrintFunction2Info(code3); } } else { } return(""); }
public static void InsertCodeInMethod(CodeFunction2 currentMethod, string codeToInsert) { TextPoint startPoint = currentMethod.GetStartPoint(vsCMPart.vsCMPartBody); // Batch insert the new code so it can be undone in 1 call to undo EditPoint pnt = startPoint.CreateEditPoint(); pnt.Insert(codeToInsert); // Format the code (indent it properly) pnt.SmartFormat(startPoint); }
/// <inheritdoc /> protected override IList <StaticParameterWrapper> GetFunctionParameters(StaticFunctionWrapper function) { CodeFunction2 functionHandle = (CodeFunction2)function.Handle; return(ConvertCodeElementsToArray <CodeParameter2, StaticParameterWrapper>(functionHandle.Parameters, delegate(CodeParameter2 parameter) { return new StaticParameterWrapper(this, parameter, function); })); }
/// <inheritdoc /> protected override StaticParameterWrapper GetMethodReturnParameter(StaticMethodWrapper method) { CodeFunction2 methodHandle = (CodeFunction2)method.Handle; // TODO: This won't provide access to any parameter attributes. How should we retrieve them? CodeTypeRef type = methodHandle.Type; return(type != null ? new StaticParameterWrapper(this, type, method) : null); }
public static void InsertCodeInMethod(CodeFunction2 currentMethod, string codeToInsert) { TextPoint startPoint = currentMethod.GetStartPoint(vsCMPart.vsCMPartBody); // Batch insert the new code so it can be undone in 1 call to undo EditPoint pnt = startPoint.CreateEditPoint(); pnt.Insert(codeToInsert); // Format the code (indent it properly) pnt.SmartFormat(startPoint); }
/// <inheritdoc /> protected override CallingConventions GetFunctionCallingConvention(StaticFunctionWrapper function) { CodeFunction2 functionHandle = (CodeFunction2)function.Handle; // FIXME: No way to determine VarArgs convention. CallingConventions flags = CallingConventions.Standard; ReflectorFlagsUtils.AddFlagIfTrue(ref flags, CallingConventions.HasThis, !functionHandle.IsShared); return(flags); }
void CreateMethod(DomRegion region) { AddCodeFile("class.cs", "class c {}"); codeModelContext.DocumentLoader = documentLoader; IMethod method = MockRepository.GenerateStub <IMethod>(); method.Stub(m => m.Region).Return(region); codeFunction = new CodeFunction2(codeModelContext, method); }
public void Members_ClassHasOneMethod_ReturnsOneMethod() { CreateProjectContent(); CreatePublicClass("MyClass"); AddMethodToClass("MyClass.MyMethod"); global::EnvDTE.CodeElements codeElements = codeClass.Members; CodeFunction2 codeFunction = codeElements.FirstCodeFunction2OrDefault(); Assert.AreEqual(1, codeElements.Count); Assert.AreEqual("MyMethod", codeFunction.Name); }
private void CreatePageMethod(CodeClass2 classModel, string name) { ParameterInfo[] parameters = _signature.GetParameters(); CodeFunction2 method = classModel.AddFunction(name, vsCMFunction.vsCMFunctionFunction, CreateCodeTypeRefName(_signature.ReturnType), -1, vsCMAccess.vsCMAccessPublic, null); method.IsShared = true; foreach (ParameterInfo param in parameters) { method.AddParameter(param.Name, CreateCodeTypeRefName(param.ParameterType), -1); } method.AddAttribute(typeof(WebMethodAttribute).FullName, "", -1); method.AddAttribute(typeof(ScriptMethodAttribute).FullName, "", -1); }
/// <summary> /// Determines if the specified code function is an explicit interface implementation. /// </summary> /// <param name="codeFunction">The code function.</param> /// <returns>True if an explicit interface implementation, otherwise false.</returns> public static bool IsExplicitInterfaceImplementation(CodeFunction2 codeFunction) { // In VS2013 and earlier, the name was reported including the interface name. if (codeFunction.Name.Contains(".")) { return true; } var declaration = CodeElementHelper.GetMethodDeclaration(codeFunction); var matchString = @"\." + codeFunction.Name; return Regex.IsMatch(declaration, matchString); }
void CreateFunction(string code) { AddCodeFile("class.cs", code); IMethod method = assemblyModel .TopLevelTypeDefinitions .First() .Members .First() .Resolve() as IMethod; codeFunction = new CodeFunction2(codeModelContext, method); }
void CreateCodeTypeRef2(string code) { AddCodeFile("class.cs", code); IMethod method = assemblyModel .TopLevelTypeDefinitions .First() .Members .First() .Resolve() as IMethod; parent = new CodeFunction2(codeModelContext, method); typeRef = parent.Type as CodeTypeRef2; }
public static void GenerateConstructor(CodeClass2 codeClass, CodeVariable2[] codeVariables, bool generateComments, vsCMAccess accessModifier) { CodeGenerator codeGenerator = CreateCodeGenerator(codeClass.Language); CodeFunction2 codeFunction = null; if (codeClass.Language == CodeModelLanguageConstants.vsCMLanguageCSharp) { codeFunction = (CodeFunction2)codeClass.AddFunction(codeClass.Name, vsCMFunction.vsCMFunctionConstructor, null, -1, accessModifier, null); } else if (codeClass.Language == CodeModelLanguageConstants.vsCMLanguageVB) { codeFunction = (CodeFunction2)codeClass.AddFunction("New", vsCMFunction.vsCMFunctionSub, vsCMTypeRef.vsCMTypeRefVoid, -1, accessModifier, null); } if (generateComments) { StringBuilder sb = new StringBuilder(); sb.AppendLine("<doc>"); sb.AppendLine("<summary>"); sb.AppendLine("</summary>"); foreach (CodeVariable2 codeVariable in codeVariables) { sb.AppendLine(String.Format("<param name=\"{0}\"></param>", codeVariable.Name)); } sb.Append("</doc>"); codeFunction.DocComment = sb.ToString(); } foreach (CodeVariable2 codeVariable in codeVariables) { codeFunction.AddParameter(codeVariable.Name, codeVariable.Type.AsString, -1); } EditPoint2 editPoint = (EditPoint2)codeFunction.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint(); foreach (CodeVariable2 codeVariable in codeVariables) { editPoint.Insert(codeGenerator.GenerateAssignStatement(codeVariable.Name, codeVariable.Name)); editPoint.SmartFormat(editPoint); if (Array.IndexOf(codeVariables, codeVariable) < codeVariables.Length - 1) { editPoint.InsertNewLine(1); } } editPoint.TryToShow(vsPaneShowHow.vsPaneShowCentered, codeFunction.StartPoint); }
private void ExpandSubCodeElement(CodeElement codeElement) { if (codeElement.Kind == vsCMElement.vsCMElementNamespace) { codeNamespace = (CodeNamespace)codeElement; } if (codeElement.Kind == vsCMElement.vsCMElementClass) { codeClass = (CodeClass2)codeElement; } if (codeElement.Kind == vsCMElement.vsCMElementFunction) { CodeFunction2 codeFunction = (CodeFunction2)codeElement; if (codeFunction.Name == "LoadContent") { loadContentFunction = codeFunction; } else if ((!open && codeFunction.Name == "Game1") /*ngikut template*/ || (open && codeFunction.Name == name)) { constructorFunction = codeFunction; } else if (codeFunction.Name == "Draw") { drawFunction = codeFunction; } else if (codeFunction.Name == "Update") { updateFunction = codeFunction; } } if (codeElement.Kind == vsCMElement.vsCMElementImportStmt) { lastImportStatement = (CodeImport)codeElement; if (((CodeImport)codeElement).Namespace == "XleModel") { xleModelImportStmtExist = true; } if (((CodeImport)codeElement).Namespace == "Jitter") { jitterImportStmtExist = true; } if (((CodeImport)codeElement).Namespace == "Jitter.Collision") { jitterCollisionImportStmtExist = true; } } foreach (CodeElement child in codeElement.Children) { ExpandSubCodeElement(child); } }
private bool PageMethodNeedsRepair(CodeFunction2 method) { if (method == null || method.Reference == null) { return(false); } ParameterInfo[] parameters = _signature.GetParameters(); // Tweak the signature so it's appropriate if (!method.IsShared) { return(true); } if (method.Access != vsCMAccess.vsCMAccessPublic) { return(true); } int i = 0; foreach (object p in method.Parameters) { CodeParameter2 parameter = new CodeParameter2(p); if ((parameter.Reference == null) || (string.Compare(parameter.Name, parameters[i++].Name, StringComparison.Ordinal) != 0)) { return(true); } } // Add the necessary attributes bool hasWebMethod = false; bool hasScriptMethod = false; foreach (object attr in method.Attributes) { CodeAttribute2 attribute = new CodeAttribute2(attr); if (attribute.Reference == null) { continue; } hasWebMethod |= !string.IsNullOrEmpty(attribute.Name) && attribute.Name.Contains("WebMethod"); hasScriptMethod |= !string.IsNullOrEmpty(attribute.Name) && attribute.Name.Contains("ScriptMethod"); if (hasWebMethod && hasScriptMethod) { break; } } return(!hasWebMethod || !hasScriptMethod); }
/// <summary> /// Determines if the specified code function is an explicit interface implementation. /// </summary> /// <param name="codeFunction">The code function.</param> /// <returns>True if an explicit interface implementation, otherwise false.</returns> public static bool IsExplicitInterfaceImplementation(CodeFunction2 codeFunction) { // In some VS editions, the name may be reported including the interface name. if (codeFunction.Name.Contains(".")) { return true; } // Otherwise, look for the element name with a preceding dot. var declaration = CodeElementHelper.GetMethodDeclaration(codeFunction); var matchString = @"\." + codeFunction.Name; return RegexNullSafe.IsMatch(declaration, matchString); }
private void RepairPageMethod(CodeFunction2 method) { if (method == null || method.Reference == null) { return; } // Tweak the signature so it's appropriate method.IsShared = true; method.Access = vsCMAccess.vsCMAccessPublic; int i = 0; ParameterInfo[] parameters = _signature.GetParameters(); foreach (object p in method.Parameters) { CodeParameter2 parameter = new CodeParameter2(p); if (parameter.Reference != null) { parameter.Name = parameters[i++].Name; } } // Add the necessary attributes bool hasWebMethod = false; bool hasScriptMethod = false; foreach (object attr in method.Attributes) { CodeAttribute2 attribute = new CodeAttribute2(attr); if (attribute.Reference == null) { continue; } hasWebMethod |= !string.IsNullOrEmpty(attribute.Name) && attribute.Name.Contains("WebMethod"); hasScriptMethod |= !string.IsNullOrEmpty(attribute.Name) && attribute.Name.Contains("ScriptMethod"); if (hasWebMethod && hasScriptMethod) { break; } } if (!hasWebMethod) { method.AddAttribute(typeof(WebMethodAttribute).FullName, "", -1); } if (!hasScriptMethod) { method.AddAttribute(typeof(ScriptMethodAttribute).FullName, "", -1); } }
/// <summary> /// Visit given element. /// </summary> /// <param name="e">Element to visit.</param> public virtual void VisitFunction(CodeFunction2 e) { if (!RecursiveVisit) { //stop recursion visitUnhandled(e); return; } foreach (CodeElement child in e.Children) { VisitElement(child); } }
public void Members_ClassHasOneMethod_ReturnsOneMethod() { CreateClass( "public class MyClass {\r\n" + " public void MyMethod() {}\r\n" + "}"); global::EnvDTE.CodeElements codeElements = codeClass.Members; CodeFunction2 codeFunction = codeElements.FirstCodeFunction2OrDefault(); Assert.AreEqual(1, codeElements.Count); Assert.AreEqual("MyMethod", codeFunction.Name); }
/// <summary> /// Determines if the specified code function is an explicit interface implementation. /// </summary> /// <param name="codeFunction">The code function.</param> /// <returns>True if an explicit interface implementation, otherwise false.</returns> public static bool IsExplicitInterfaceImplementation(CodeFunction2 codeFunction) { // In some VS editions, the name may be reported including the interface name. if (codeFunction.Name.Contains(".")) { return(true); } // Otherwise, look for the element name with a preceding dot. var declaration = CodeElementHelper.GetMethodDeclaration(codeFunction); var matchString = @"\." + codeFunction.Name; return(RegexNullSafe.IsMatch(declaration, matchString)); }
public override void Exec(vsCommandExecOption executeOption, ref object varIn, ref object varOut) { CodeFunction2 currentMethod = CodeModelUtils.GetCurrentMethod(m_application); if (IsCommandAvailable(currentMethod)) { AndroMDA.VS80AddIn.Dialogs.PropertyMapperDialog propertyMapper = new AndroMDA.VS80AddIn.Dialogs.PropertyMapperDialog(currentMethod, m_addInSettings); if (propertyMapper.ShowDialog() == System.Windows.Forms.DialogResult.OK) { // User clicked OK AddInUtils.InsertCodeInMethod(currentMethod, propertyMapper.GeneratedCode); m_application.StatusBar.Text = "Android/VS: Code inserted"; } } }
private string getSignature(CodeFunction2 f) { var paramlist = new List <string>(); foreach (CodeElement p in f.Parameters) { var cp = p as CodeParameter; if (cp != null) { paramlist.Add(string.Format("{0}", cp.Name)); } } return(getFunctionName(f) + "(" + string.Join(",", paramlist) + ")"); }
/// <inheritdoc /> protected override IEnumerable <StaticConstructorWrapper> GetTypeConstructors(StaticDeclaredTypeWrapper type) { CodeType typeHandle = (CodeType)type.Handle; foreach (CodeElement candidate in typeHandle.Members) { if (candidate.Kind == vsCMElement.vsCMElementFunction) { CodeFunction2 function = (CodeFunction2)candidate; if (function.FunctionKind == vsCMFunction.vsCMFunctionConstructor) { yield return(new StaticConstructorWrapper(this, function, type)); } } } }
private bool IsCommandAvailable(CodeFunction2 currentMethod, bool fullCheck) { if ( // Ensure we found the current method currentMethod != null && // That it has one parameter currentMethod.Parameters.Count == 1 && /* * // That it is an override * currentMethod.OverrideKind == vsCMOverrideKind.vsCMOverrideKindOverride && */ // That it is function (method) currentMethod.FunctionKind == vsCMFunction.vsCMFunctionFunction && // That it exists inside a project currentMethod.InfoLocation == vsCMInfoLocation.vsCMInfoLocationProject && // It's return type is not void currentMethod.Type.AsString != "void" && // The return type does not equal the parameter type ((CodeParameter2)currentMethod.Parameters.Item(1)).Type.AsFullName != currentMethod.Type.AsFullName && // And it's name is either ends with ToEntity or begins with To ((currentMethod.Name.EndsWith("ToEntity") || currentMethod.Name.StartsWith("To")) || !m_addInSettings.OnlyEnableCodeGenOnConversionMethods) ) { if (!fullCheck) { return(true); } CodeParameter2 param = currentMethod.Parameters.Item(1) as CodeParameter2; CodeClass2 containingClass = currentMethod.Parent as CodeClass2; if (// Ensure we found the parameter and the parent class param != null && containingClass != null && (!m_addInSettings.OnlyEnableCodeGenInDaoImpl || // Ensure we are in a DaoImpl class containingClass.Name.Contains("DaoImpl")) ) { return(true); } } return(false); }
private bool IsCommandAvailable(CodeFunction2 currentMethod, bool fullCheck) { if ( // Ensure we found the current method currentMethod != null && // That it has one parameter currentMethod.Parameters.Count == 1 && /* // That it is an override currentMethod.OverrideKind == vsCMOverrideKind.vsCMOverrideKindOverride && */ // That it is function (method) currentMethod.FunctionKind == vsCMFunction.vsCMFunctionFunction && // That it exists inside a project currentMethod.InfoLocation == vsCMInfoLocation.vsCMInfoLocationProject && // It's return type is not void currentMethod.Type.AsString != "void" && // The return type does not equal the parameter type ((CodeParameter2)currentMethod.Parameters.Item(1)).Type.AsFullName != currentMethod.Type.AsFullName && // And it's name is either ends with ToEntity or begins with To ((currentMethod.Name.EndsWith("ToEntity") || currentMethod.Name.StartsWith("To")) || !m_addInSettings.OnlyEnableCodeGenOnConversionMethods) ) { if (!fullCheck) return true; CodeParameter2 param = currentMethod.Parameters.Item(1) as CodeParameter2; CodeClass2 containingClass = currentMethod.Parent as CodeClass2; if (// Ensure we found the parameter and the parent class param != null && containingClass != null && (!m_addInSettings.OnlyEnableCodeGenInDaoImpl || // Ensure we are in a DaoImpl class containingClass.Name.Contains("DaoImpl")) ) { return true; } } return false; }
/// <summary> /// Performs any preparatory tasks that have to be done after a new unit test project has been created. /// </summary> /// <param name="unitTestProject">The <see cref="Project"/> of the unit test project that has just been created.</param> /// <param name="sourceMethod">The <see cref="CodeFunction2"/> of the source method that is to be unit tested.</param> protected override void OnUnitTestProjectCreated(Project unitTestProject, CodeFunction2 sourceMethod) { if (unitTestProject == null) { throw new ArgumentNullException(nameof(unitTestProject)); } TraceLogger.LogInfo("NUnitSolutionManager.OnUnitTestProjectCreated: Adding reference to NUnit assemblies through nuget."); base.OnUnitTestProjectCreated(unitTestProject, sourceMethod); this.EnsureNuGetReference(unitTestProject, "NUnit", null); var vsp = unitTestProject.Object as VSProject2; var reference = vsp?.References.Find(GlobalConstants.MSTestAssemblyName); if (reference != null) { TraceLogger.LogInfo("NUnitSolutionManager.OnUnitTestProjectCreated: Removing reference to {0}", reference.Name); reference.Remove(); } }
protected virtual bool AcceptConstructor(CodeFunction2 method) { return method.Name == this.Name && method.FunctionKind == vsCMFunction.vsCMFunctionConstructor; }
internal NotifyPropertyChanged_GenAttribute(CodeFunction2 f) : base(f) { Init(); }
/// <summary> /// Returns the parameters list from a function. /// </summary> /// <param name="element">A CodeFunction2 object.</param> /// <returns>A string with function parameters.</returns> private static string ExtractMethodParameters(CodeFunction2 element) { // Get the string holding the stub definition of this function. string temp = element.get_Prototype((int)vsCMPrototype.vsCMPrototypeParamTypes); int len = temp.Length; int index = temp.LastIndexOf('('); string str = null; try { str = temp.Substring(index, len - index); } catch (ArgumentNullException) { str = null; } return str; }
private CodeDomMethodMetadata(CodeFunction2 codeFunction, CodeDomFileMetadata file) { this.codeFunction = codeFunction; this.file = file; }
internal GeneratorAttribute(CodeFunction2 f) { ParentFunction = f; Init(f.AsCodeElement()); }
public CodeConstructorInfo(BaseInfo parent, CodeFunction2 method) : base(parent, method) { }
/// <summary> /// Determines if the specified code function is an explicit interface implementation. /// </summary> /// <param name="codeFunction">The code function.</param> /// <returns>True if an explicit interface implementation, otherwise false.</returns> public static bool IsExplicitInterfaceImplementation(CodeFunction2 codeFunction) { return codeFunction != null && codeFunction.Name.Contains("."); }
protected virtual bool AcceptDestructor(CodeFunction2 method) { return method.FunctionKind == vsCMFunction.vsCMFunctionDestructor; }
internal AttributeProcessor(CodeFunction2 f) { ParentFunction = f; Init(f.AsCodeElement()); }
public void SyncWithCode(bool forceRun = false) { var doc = ApplicationObject.ActiveDocument; if (doc == null) return; // // Fetch the selected bit of code // var sel = (TextSelection)doc.Selection; var p = sel.ActivePoint; var funcElm = (CodeFunction2)p.CodeElement[vsCMElement.vsCMElementFunction]; if (funcElm == null) { var propElm = (CodeProperty2)p.CodeElement[vsCMElement.vsCMElementProperty]; if (propElm != null) { var getter = propElm.Getter; var setter = propElm.Setter; if (getter != null && p.GreaterThan (getter.StartPoint) && p.LessThan (getter.EndPoint)) { funcElm = (CodeFunction2)getter; } else if (setter != null && p.GreaterThan (setter.StartPoint) && p.LessThan (setter.EndPoint)) { funcElm = (CodeFunction2)setter; } } } // // Make sure it's .NET (C# and VB) // if (funcElm != null) { if (funcElm.Language != CodeModelLanguageConstants.vsCMLanguageCSharp && funcElm.Language != CodeModelLanguageConstants.vsCMLanguageVB) { funcElm = null; } } if (funcElm == null) return; // // Handle it // var newFunc = false; if (_funcElm == null || GetMemberName (funcElm) != _tests.Member) { _funcElm = funcElm; SetMember (); DisplayFunction (); newFunc = true; } if (forceRun || newFunc) { RunAllRows (); } }
public CodeMethodNodeFactory(CodeFunction2 element) : base(element as CodeElement) { _element = element; }
internal ShellCodeMethod(CodeFunction2 method) : base(method as CodeElement2) { _method = method; }
/// <summary> /// /// </summary> protected virtual bool AcceptMethod(CodeFunction2 method) { return method.FunctionKind == vsCMFunction.vsCMFunctionFunction; }
/// <summary> /// /// </summary> public virtual CodeFunctionInfo CreateMethod(BaseInfo parent, CodeFunction2 item) { return new CodeFunctionInfo(parent, item); }
private Function ParseFunction(CodeFunction2 codeFunction, string currentFile) { var function = new Function {Name = codeFunction.Name, Type = codeFunction.Type.AsString, Access = codeFunction.Access.Convert(), FileName = currentFile}; WriteLine("ParseFunction" + " " + function.Name + " " + function.Type); foreach (CodeAttribute2 codeElement in codeFunction.Attributes) { ParseAttribute(codeElement, function, currentFile); } foreach (var codeParameter in codeFunction.Parameters.Cast<CodeParameter2>()) { var parmeter = ParseParameter(codeParameter); function.Parameters.Add(parmeter); } return function; }
/// <summary> /// /// </summary> public virtual CodeConstructorInfo CreateConstructor(BaseInfo parent, CodeFunction2 item) { return new CodeConstructorInfo(parent, item); }
private bool IsCommandAvailable(CodeFunction2 currentMethod) { return IsCommandAvailable(currentMethod, true); }
public static ITypeMetadata FromCodeElement(CodeFunction2 codeVariable, CodeDomFileMetadata file) { return GetType(codeVariable, file); }