public void ParameterNameSafe_PositiveCase() { const string reserved_word = "this"; ParameterDeclarationExpression p = new ParameterDeclarationExpression(new TypeReference("foo"), reserved_word); Assert.AreEqual("@this", p.ParameterNameSafe()); }
public static MethodDeclaration add_Method(this TypeDeclaration typeDeclaration, string methodName, Dictionary <string, object> invocationParameters, BlockStatement body) { var newMethod = new MethodDeclaration { Name = methodName, //Modifier = Modifiers.None | Modifiers.Public | Modifiers.Static, Modifier = Modifiers.None | Modifiers.Public, Body = body }; newMethod.setReturnType(); if (invocationParameters != null) { foreach (var invocationParameter in invocationParameters) { var parameterType = new TypeReference( (invocationParameter.Value != null && invocationParameter.Key != "returnData") ? invocationParameter.Value.typeFullName() : "System.Object", true); var parameter = new ParameterDeclarationExpression(parameterType, invocationParameter.Key); newMethod.Parameters.Add(parameter); } } typeDeclaration.AddChild(newMethod); return(newMethod); }
public void ParameterNameSafe_NegativeCase() { const string not_a_reserverd_word = "not_a_reserverd_word"; ParameterDeclarationExpression p = new ParameterDeclarationExpression(new TypeReference("foo"), not_a_reserverd_word); Assert.AreEqual("not_a_reserverd_word", p.ParameterNameSafe()); }
public void IndexOf() { string program = TestUtil.GetInput(); CompilationUnit cu = TestUtil.ParseProgram(program); NamespaceDeclaration ns = (NamespaceDeclaration)cu.Children[0]; TypeDeclaration ty = (TypeDeclaration)ns.Children[0]; IList methodDecList = AstUtil.GetChildrenWithType(ty, typeof(MethodDeclaration)); ParameterDeclarationExpression p1 = new ParameterDeclarationExpression(new TypeReference("Circle"), "circle"); p1.TypeReference.RankSpecifier = new int[] {}; List <ParameterDeclarationExpression> md1Param = new List <ParameterDeclarationExpression>(); md1Param.Add(p1); MethodDeclaration md1 = new MethodDeclaration("GetRadius", Modifiers.Private, new TypeReference("int"), md1Param, null); int md1Index = IndexOf(methodDecList, md1); Assert.AreEqual(1, md1Index); MethodDeclaration md2 = new MethodDeclaration("ToString", Modifiers.Protected, new TypeReference("string"), null, null); int md2Index = IndexOf(methodDecList, md2); Assert.AreEqual(-1, md2Index); }
/// <summary> /// Called when a method is visited. /// </summary> /// <param name="methodDeclaration"></param> /// <param name="data"></param> /// <returns></returns> public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { INode nodeParent = methodDeclaration.Parent; if (nodeParent is TypeDeclaration) { TypeDeclaration typeDeclaration = (TypeDeclaration)methodDeclaration.Parent; EventType evt = new EventType(); evt.id = methodDeclaration.Name; if (methodDeclaration.Parameters.Count > 0) { evt.parameter = new ParameterType[methodDeclaration.Parameters.Count]; for (int i = 0; i < methodDeclaration.Parameters.Count; i++) { ParameterDeclarationExpression paramDecl = methodDeclaration.Parameters[i]; ParameterType param = new ParameterType(); param.name = paramDecl.ParameterName; param.type = paramDecl.TypeReference.ToString(); evt.parameter[i] = param; } } model.AddEvent(evt); model.AddEventToFeeder(feeder, evt.id); } return(base.VisitMethodDeclaration(methodDeclaration, data)); }
public override List <Change> PerformChanges(RefactoringOptions options, object prop) { IResolver resolver = options.GetResolver(); List <Change> result = new List <Change> (); INRefactoryASTProvider provider = options.GetASTProvider(); if (resolver == null || provider == null) { return(result); } TypeDeclaration newType = new TypeDeclaration(ICSharpCode.NRefactory.Ast.Modifiers.None, null); newType.Name = createExpression.CreateType.Type; newType.Type = GetNewTypeType(); ConstructorDeclaration constructor = new ConstructorDeclaration(newType.Name, ICSharpCode.NRefactory.Ast.Modifiers.Public, null, null); constructor.Body = new BlockStatement(); int i = 0; foreach (Expression expression in createExpression.Parameters) { i++; string output = provider.OutputNode(options.Dom, expression); string parameterName; if (Char.IsLetter(output[0]) || output[0] == '_') { parameterName = output; } else { parameterName = "par" + i; } ResolveResult resolveResult2 = resolver.Resolve(new ExpressionResult(output), options.ResolveResult.ResolvedExpression.Region.Start); TypeReference typeReference = new TypeReference(resolveResult2.ResolvedType.ToInvariantString()); typeReference.IsKeyword = true; ParameterDeclarationExpression pde = new ParameterDeclarationExpression(typeReference, parameterName); constructor.Parameters.Add(pde); } ICSharpCode.NRefactory.Ast.INode node = newType; IType curType = options.Document.CompilationUnit.GetTypeAt(options.Document.Editor.Caret.Line, options.Document.Editor.Caret.Column); if (curType != null && !string.IsNullOrEmpty(curType.Namespace)) { NamespaceDeclaration namespaceDeclaration = new NamespaceDeclaration(curType.Namespace); namespaceDeclaration.Children.Add(newType); node = namespaceDeclaration; } newType.Children.Add(constructor); string fileName = GetName(Path.Combine(Path.GetDirectoryName(options.Document.FileName), newType.Name + Path.GetExtension(options.Document.FileName))); string header = options.Dom.Project is DotNetProject?StandardHeaderService.GetHeader(options.Dom.Project, fileName, true) + Environment.NewLine : ""; CreateFileChange createFile = new CreateFileChange(fileName, header + provider.OutputNode(options.Dom, node)); result.Add(createFile); result.Add(new OpenFileChange(fileName)); return(result); }
public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) { if (!IsClassType(ClassType.Interface) && (propertyDeclaration.Modifier & Modifiers.Visibility) == 0) { propertyDeclaration.Modifier |= Modifiers.Public; } if (propertyDeclaration.HasSetRegion) { string from = "Value"; if (propertyDeclaration.SetRegion.Parameters.Count > 0) { ParameterDeclarationExpression p = propertyDeclaration.SetRegion.Parameters[0]; from = p.ParameterName; p.ParameterName = "Value"; } propertyDeclaration.SetRegion.AcceptVisitor(new RenameIdentifierVisitor(from, "value", StringComparer.InvariantCultureIgnoreCase), null); } if (propertyDeclaration.HasGetRegion && propertyDeclaration.GetRegion.Block.Children.Count > 0) { BlockStatement block = propertyDeclaration.GetRegion.Block; ReplaceAllFunctionAssignments(block, propertyDeclaration.Name, propertyDeclaration.TypeReference); } return(base.VisitPropertyDeclaration(propertyDeclaration, data)); }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { if (methodDeclaration.Name.ToLower().Equals("main") && !methodDeclaration.Modifier.HasFlag(Modifiers.Constructors)) { if (!methodDeclaration.IsExtensionMethod && !methodDeclaration.Modifier.HasFlag(Modifiers.Abstract)) { if (methodDeclaration.Parameters.Count == 1) { ParameterDeclarationExpression param = methodDeclaration.Parameters[0]; if (param.ParameterName.Equals("args") && param.TypeReference.ToString().Equals("System.String[]")) { //now check if body uses argsparam //This is waaaaay to naive.... if (methodDeclaration.Body.ToString().Contains("args")) { UnlockWith(methodDeclaration); } } } } } return(base.VisitMethodDeclaration(methodDeclaration, data)); }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { base.VisitMethodDeclaration(methodDeclaration, data); // visit parameters methodDeclaration.Attributes.Clear(); methodDeclaration.Body = new BlockStatement(); methodDeclaration.Modifier = Modifiers.Public; if (methodDeclaration.Parameters.Count > 0) { ParameterDeclarationExpression lastParameter = methodDeclaration.Parameters[methodDeclaration.Parameters.Count - 1]; if (lastParameter.ParamModifier == ParameterModifiers.Out) { methodDeclaration.TypeReference = lastParameter.TypeReference; methodDeclaration.Parameters.RemoveAt(methodDeclaration.Parameters.Count - 1); VariableDeclaration tmpVarDecl = new VariableDeclaration("tmp"); tmpVarDecl.TypeReference = methodDeclaration.TypeReference; methodDeclaration.Body.AddChild(new LocalVariableDeclaration(tmpVarDecl)); IdentifierExpression tmpIdent = new IdentifierExpression("tmp"); InvocationExpression ie = CreateMethodCall(methodDeclaration); ie.Arguments.Add(new DirectionExpression(FieldDirection.Out, tmpIdent)); methodDeclaration.Body.AddChild(new ExpressionStatement(ie)); methodDeclaration.Body.AddChild(new ReturnStatement(tmpIdent)); return(null); } } methodDeclaration.Body.AddChild(new ExpressionStatement(CreateMethodCall(methodDeclaration))); return(null); }
public void Equals() { string program = TestUtil.TypeMemberParse("public string Sentence(string title , string text);"); CompilationUnit cu = TestUtil.ParseProgram(program); NamespaceDeclaration ns = (NamespaceDeclaration)cu.Children[0]; TypeDeclaration ty = (TypeDeclaration)ns.Children[0]; MethodDeclaration pgMethod = (MethodDeclaration)ty.Children[0]; ParameterDeclarationExpression p1 = new ParameterDeclarationExpression(new TypeReference("string"), "title"); p1.TypeReference.RankSpecifier = new int[] {}; ParameterDeclarationExpression p2 = new ParameterDeclarationExpression(new TypeReference("string"), "text"); p2.TypeReference.RankSpecifier = new int[] {}; List <ParameterDeclarationExpression> argList = new List <ParameterDeclarationExpression>(); argList.Add(p1); argList.Add(p2); MethodDeclaration exMethod = new MethodDeclaration("Sentence", Modifiers.Public, new TypeReference("string"), argList, null); Assert.IsTrue(Equals(exMethod, pgMethod)); string program2 = TestUtil.TypeMemberParse("public string Sentence(string title , string[] text);"); cu = TestUtil.ParseProgram(program2); ns = (NamespaceDeclaration)cu.Children[0]; ty = (TypeDeclaration)ns.Children[0]; pgMethod = (MethodDeclaration)ty.Children[0]; Assert.IsFalse(Equals(exMethod, pgMethod)); }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (nameComparer.Equals(from, parameterDeclarationExpression.ParameterName)) { parameterDeclarationExpression.ParameterName = to; } return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data); }
public override object TrackedVisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (keywords.Contains(parameterDeclarationExpression.ParameterName)) { parameterDeclarationExpression.ParameterName = "_" + parameterDeclarationExpression.ParameterName; } return(base.TrackedVisitParameterDeclarationExpression(parameterDeclarationExpression, data)); }
public static ParameterDeclarationExpression AddParameter(this MethodDeclaration methodDeclaration, string name, string parameterType) { var result = new ParameterDeclarationExpression(new TypeReference(parameterType), name); methodDeclaration.Parameters.Add(result); return(result); }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (this.CheckNode(parameterDeclarationExpression)) { return(null); } return(base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data)); }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (nameComparer.Equals(from, parameterDeclarationExpression.ParameterName)) { parameterDeclarationExpression.ParameterName = to; } return(base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data)); }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (parameterDeclarationExpressionVisit != null) { data = parameterDeclarationExpressionVisit(parameterDeclarationExpression, data); } return(base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data)); }
/// <summary> /// Adds a <see cref="ParameterDeclarationExpression"/> to <see cref="ParametrizedNode.Parameters"/> in a single /// call, for convenience. /// </summary> /// /// <param name="node"> /// The method or constructor to add the parameter to. /// </param> /// /// <param name="parameterType"> /// The <see cref="TypeReference"/> of the parameter to add. /// </param> /// /// <param name="parameterName"> /// The name of the parameter to add. /// </param> /// /// <returns> /// The <see cref="ParameterDeclarationExpression"/> instance that was created and added to /// <paramref name="node"/>. /// </returns> public static ParameterDeclarationExpression AddParameter(this ParametrizedNode node, TypeReference parameterType, string parameterName) { var parameter = new ParameterDeclarationExpression(parameterType, parameterName); node.Parameters.Add(parameter); return(parameter); }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (parameterDeclarationExpression.ParamModifier == ParameterModifiers.Params) { UnlockWith(parameterDeclarationExpression); } return(base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data)); }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (RenameTable.ContainsKey(parameterDeclarationExpression.ParameterName)) { parameterDeclarationExpression.ParameterName = RenameTable[parameterDeclarationExpression.ParameterName]; } return(null); }
public Variable(Location start, Location end, ParameterDeclarationExpression param) { this.Type = param.TypeReference; this.Name = param.ParameterName; this.StartPos = start; this.EndPos = end; this.Initializer = param.DefaultValue; this.WasOutParam = (param.ParamModifier & ParameterModifiers.Out) == ParameterModifiers.Out; this.WasRefParam = (param.ParamModifier & ParameterModifiers.Ref) == ParameterModifiers.Ref; }
/// <summary> /// Prepends a @ to a parameter name in case the name chosen is also a keyword. /// </summary> /// <param name="pde"></param> /// <returns></returns> public static string ParameterNameSafe(this ParameterDeclarationExpression pde) { var p_name = pde.ParameterName; if (Keywords.IsNonIdentifierKeyword(p_name)) { return("@" + p_name); } return(p_name); }
public Variable(BlockStatement block, ParameterDeclarationExpression param) { this.Type = param.TypeReference; this.Name = param.ParameterName; this.StartPos = block.StartLocation; this.EndPos = block.EndLocation; this.Initializer = param.DefaultValue; this.WasOutParam = (param.ParamModifier & ParameterModifiers.Out) == ParameterModifiers.Out; this.WasRefParam = (param.ParamModifier & ParameterModifiers.Ref) == ParameterModifiers.Ref; }
public void GenerateTestMethod_InstanceMethod() { #region public class Cruncher var classUnderTest = new TypeDeclaration(Modifiers.Public, null) { Name = "Cruncher" }; #region internal int SafeCrunch ( int x, int y ) var methodToTest = new MethodDeclaration { Name = "SafeCrunch", Modifier = Modifiers.Internal }; #region returns int var retval = new TypeReference("int", true); methodToTest.TypeReference = retval; #endregion #region int x var xParam = new ParameterDeclarationExpression(new TypeReference("int", true), "x"); methodToTest.Parameters.Add(xParam); #endregion #region int y var yParam = new ParameterDeclarationExpression(new TypeReference("int", true), "y"); methodToTest.Parameters.Add(yParam); #endregion #endregion classUnderTest.Children.Add(methodToTest); #endregion const string expected = @" /// <summary> /// Tests the <c>SafeCrunch</c> method with /// TODO: write about scenario /// </summary> [Test()] public void SafeCrunch_TODO() { Cruncher cruncher = new Cruncher(); Assert.Fail(""TODO: initialize variable(s) and expected value""); int x = 0; int y = 0; int actual = cruncher.SafeCrunch(x, y); int expected = 0; Assert.AreEqual(expected, actual); } "; Assert.AreEqual(expected, Parent.UnitTest.GenerateTestMethod(methodToTest, classUnderTest)); }
// general: public virtual object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data) { Debug.Assert(parameterDeclarationExpression != null); Debug.Assert(parameterDeclarationExpression.Attributes != null); Debug.Assert(parameterDeclarationExpression.TypeReference != null); foreach (AttributeSection section in parameterDeclarationExpression.Attributes) { Debug.Assert(section != null); section.AcceptVisitor(this, data); } return(parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data)); }
private bool ContainsParameter(IList parameters, ParameterDeclarationExpression parameterDeclaration) { foreach (ParameterDeclarationExpression parameter in parameters) { if (parameterDeclaration.ParameterName == parameter.ParameterName && parameterDeclaration.TypeReference.Type == parameter.TypeReference.Type) { return(true); } } return(false); }
public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data) { if (invocationExpression.TargetObject is IdentifierExpression) { TypeDeclaration typeDeclaration = (TypeDeclaration)AstUtil.GetParentOfType(invocationExpression, typeof(TypeDeclaration)); IdentifierExpression methodIdentifier = (IdentifierExpression)invocationExpression.TargetObject; if (typeDeclaration.Parent is TypeDeclaration) { List <ParameterDeclarationExpression> argList = new List <ParameterDeclarationExpression>(); int i = 0; foreach (Expression argument in invocationExpression.Arguments) { TypeReference argumentType = GetExpressionType(argument); if (argumentType != null) { string argType = argumentType.Type; TypeReference typeReference = new TypeReference(argType); ParameterDeclarationExpression parameterExpression = new ParameterDeclarationExpression(typeReference, "arg" + i); parameterExpression.TypeReference.RankSpecifier = new int[0]; i++; argList.Add(parameterExpression); } } MethodDeclaration argMethod = new MethodDeclaration(methodIdentifier.Identifier, Modifiers.None, null, argList, null); IList parentMethods = GetAccessibleMethods((TypeDeclaration)typeDeclaration.Parent); if (Contains(parentMethods, argMethod)) { int methodIndex = IndexOf(parentMethods, argMethod); argMethod = (MethodDeclaration)parentMethods[methodIndex]; if (!AstUtil.ContainsModifier(argMethod, Modifiers.Static)) { string parentTypeName = ((TypeDeclaration)typeDeclaration.Parent).Name; AddInstanceField(typeDeclaration, parentTypeName); AddProperConstructor(typeDeclaration, parentTypeName); FieldReferenceExpression newReference = new FieldReferenceExpression( new IdentifierExpression(parentTypeName), ((IdentifierExpression)invocationExpression.TargetObject).Identifier); InvocationExpression newInvication = new InvocationExpression(newReference, invocationExpression.Arguments); newInvication.Parent = invocationExpression.Parent; ReplaceCurrentNode(newInvication); } } } } return(base.TrackedVisitInvocationExpression(invocationExpression, data)); }
private void AddProperConstructor(TypeDeclaration typeDeclaration, string instanceFieldName) { TypeReference type = new TypeReference(instanceFieldName); ParameterDeclarationExpression fieldParameter = new ParameterDeclarationExpression(type, instanceFieldName); FieldReferenceExpression fieldReference = new FieldReferenceExpression(new ThisReferenceExpression(), instanceFieldName); IdentifierExpression right = new IdentifierExpression(instanceFieldName); AssignmentExpression assignment = new AssignmentExpression(fieldReference, AssignmentOperatorType.Assign, right); ExpressionStatement expressionStatement = new ExpressionStatement(assignment); string fullName = GetFullName(typeDeclaration); IList constructors = AstUtil.GetChildrenWithType(typeDeclaration, typeof(ConstructorDeclaration)); if (constructors.Count == 0) { string name = typeDeclaration.Name; List <ParameterDeclarationExpression> parameters = new List <ParameterDeclarationExpression>(); parameters.Add(fieldParameter); ConstructorDeclaration constructorDeclaration = new ConstructorDeclaration(name, Modifiers.Public, parameters, null); constructorDeclaration.Body = new BlockStatement(); constructorDeclaration.Body.AddChild(expressionStatement); constructorDeclaration.Parent = typeDeclaration; CodeBase.References.Add("Cons:" + fullName, null); typeDeclaration.Children.Add(constructorDeclaration); } else { foreach (ConstructorDeclaration constructor in constructors) { if (!ContainsParameter(constructor.Parameters, fieldParameter)) { constructor.Parameters.Add(fieldParameter); if (constructor.ConstructorInitializer != null) { ConstructorInitializer ci = constructor.ConstructorInitializer; if (ci.ConstructorInitializerType == ConstructorInitializerType.This) { ci.Arguments.Add(new IdentifierExpression(fieldParameter.ParameterName)); } } constructor.Body.Children.Insert(0, expressionStatement); } } if (!CodeBase.References.Contains("Cons:" + fullName)) { CodeBase.References.Add("Cons:" + fullName, null); } } }
public void GenerateTestMethod_Typical() { #region public static class Unformatter var classUnderTest = new TypeDeclaration(Modifiers.Public | Modifiers.Static, null) { Name = "Unformatter" }; #region public static string[] Unformat ( this string format, string formatted ) var methodToTest = new MethodDeclaration { Name = "Unformat", IsExtensionMethod = true, Modifier = Modifiers.Static }; #region returns string[] var retval = new TypeReference("string", new[] { 0 }); methodToTest.TypeReference = retval; #endregion #region string format var formatParam = new ParameterDeclarationExpression(new TypeReference("string", true), "format"); methodToTest.Parameters.Add(formatParam); #endregion #region string formatted var formattedParam = new ParameterDeclarationExpression(new TypeReference("string", true), "formatted"); methodToTest.Parameters.Add(formattedParam); #endregion #endregion classUnderTest.Children.Add(methodToTest); #endregion const string expected = @" /// <summary> /// Tests the <c>Unformat</c> method with /// TODO: write about scenario /// </summary> [Test()] public void Unformat_TODO() { Assert.Fail(""TODO: initialize variable(s) and expected value""); string format = ""TODO""; string formatted = ""TODO""; string[] actual = Unformatter.Unformat(format, formatted); string[] expected = default(string[]); Assert.AreEqual(expected, actual); } "; Assert.AreEqual(expected, Parent.UnitTest.GenerateTestMethod(methodToTest, classUnderTest)); }
public static List <ParameterDeclarationExpression> ConvertParameters(IList <IParameter> parameters, ClassFinder targetContext) { List <ParameterDeclarationExpression> l = new List <ParameterDeclarationExpression>(parameters.Count); foreach (IParameter p in parameters) { ParameterDeclarationExpression pd = new ParameterDeclarationExpression(ConvertType(p.ReturnType, targetContext), p.Name, ConvertModifier(p.Modifiers)); pd.Attributes = ConvertAttributes(p.Attributes, targetContext); l.Add(pd); } return(l); }
public void GenerateTestMethod_MethodWithNotReturnValue() { #region public class Cruncher var classUnderTest = new TypeDeclaration(Modifiers.Public, null) { Name = "Cruncher" }; #region public static void CrunchNumbers ( int x, int y ) var methodToTest = new MethodDeclaration { Name = "CrunchNumbers", Modifier = Modifiers.Public | Modifiers.Static }; #region returns void var retval = new TypeReference("void", true); methodToTest.TypeReference = retval; #endregion #region int x var xParam = new ParameterDeclarationExpression(new TypeReference("int", true), "x"); methodToTest.Parameters.Add(xParam); #endregion #region int y var yParam = new ParameterDeclarationExpression(new TypeReference("int", true), "y"); methodToTest.Parameters.Add(yParam); #endregion #endregion classUnderTest.Children.Add(methodToTest); #endregion const string expected = @" /// <summary> /// Tests the <c>CrunchNumbers</c> method with /// TODO: write about scenario /// </summary> [Test()] public void CrunchNumbers_TODO() { Assert.Fail(""TODO: initialize variable(s)""); int x = 0; int y = 0; Cruncher.CrunchNumbers(x, y); } "; Assert.AreEqual(expected, Parent.UnitTest.GenerateTestMethod(methodToTest, classUnderTest)); }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { if (IncludeParameters) { if (parameterDeclarationExpression == null) { return(data); } AddVariable(parameterDeclarationExpression.TypeReference, parameterDeclarationExpression.ParameterName, parameterDeclarationExpression.StartLocation, parameterDeclarationExpression.EndLocation, false, false, NullExpression.Instance, null); } return(base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data)); }
public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { Debug.Assert((parameterDeclarationExpression != null)); Debug.Assert((parameterDeclarationExpression.Attributes != null)); Debug.Assert((parameterDeclarationExpression.TypeReference != null)); Debug.Assert((parameterDeclarationExpression.DefaultValue != null)); foreach (AttributeSection o in parameterDeclarationExpression.Attributes) { Debug.Assert(o != null); o.AcceptVisitor(this, data); } parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data); return parameterDeclarationExpression.DefaultValue.AcceptVisitor(this, data); }
public virtual object TrackedVisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data); }
void AddParameter (AbstractCSharpNode parent, Mono.CSharp.AParametersCollection parameters) { if (parameters == null) return; var paramLocation = LocationsBag.GetLocations (parameters); for (int i = 0; i < parameters.Count; i++) { if (paramLocation != null && i > 0 && i - 1 < paramLocation.Count) parent.AddChild (new CSharpTokenNode (Convert (paramLocation[i - 1]), 1), ParameterDeclarationExpression.Roles.Comma); var p = (Parameter)parameters.FixedParameters[i]; var location = LocationsBag.GetLocations (p); ParameterDeclarationExpression parameterDeclarationExpression = new ParameterDeclarationExpression (); switch (p.ModFlags) { case Parameter.Modifier.OUT: parameterDeclarationExpression.ParameterModifier = ParameterModifier.Out; if (location != null) parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "out".Length), ParameterDeclarationExpression.Roles.Keyword); break; case Parameter.Modifier.REF: parameterDeclarationExpression.ParameterModifier = ParameterModifier.Ref; if (location != null) parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "ref".Length), ParameterDeclarationExpression.Roles.Keyword); break; case Parameter.Modifier.PARAMS: parameterDeclarationExpression.ParameterModifier = ParameterModifier.Params; if (location != null) parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "params".Length), ParameterDeclarationExpression.Roles.Keyword); break; case Parameter.Modifier.This: parameterDeclarationExpression.ParameterModifier = ParameterModifier.This; if (location != null) parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), "this".Length), ParameterDeclarationExpression.Roles.Keyword); break; } if (p.TypeExpression != null) // lambdas may have no types (a, b) => ... parameterDeclarationExpression.AddChild ((INode)p.TypeExpression.Accept (this), ParameterDeclarationExpression.Roles.ReturnType); parameterDeclarationExpression.AddChild (new Identifier (p.Name, Convert (p.Location)), ParameterDeclarationExpression.Roles.Identifier); if (p.HasDefaultValue) { if (location != null) parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ParameterDeclarationExpression.Roles.Assign); parameterDeclarationExpression.AddChild ((INode)p.DefaultValue.Accept (this), ParameterDeclarationExpression.Roles.Expression); } parent.AddChild (parameterDeclarationExpression, InvocationExpression.Roles.Argument); } }
public sealed override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { BeginVisit(parameterDeclarationExpression); object result = TrackedVisitParameterDeclarationExpression(parameterDeclarationExpression, data); EndVisit(parameterDeclarationExpression); return result; }
private void FixedParameter(out ParameterDeclarationExpression p) { TypeReference reference; ParamModifier @in = ParamModifier.In; Point location = this.t.Location; if ((this.la.kind == 0x5c) || (this.la.kind == 0x63)) { if (this.la.kind == 0x63) { base.lexer.NextToken(); @in = ParamModifier.Ref; } else { base.lexer.NextToken(); @in = ParamModifier.Out; } } this.Type(out reference); base.Expect(1); p = new ParameterDeclarationExpression(reference, this.t.val, @in); p.StartLocation = location; p.EndLocation = this.t.Location; }
public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { Debug.Assert((parameterDeclarationExpression != null)); Debug.Assert((parameterDeclarationExpression.Attributes != null)); Debug.Assert((parameterDeclarationExpression.TypeReference != null)); Debug.Assert((parameterDeclarationExpression.DefaultValue != null)); for (int i = 0; i < parameterDeclarationExpression.Attributes.Count; i++) { AttributeSection o = parameterDeclarationExpression.Attributes[i]; Debug.Assert(o != null); nodeStack.Push(o); o.AcceptVisitor(this, data); o = (AttributeSection)nodeStack.Pop(); if (o == null) parameterDeclarationExpression.Attributes.RemoveAt(i--); else parameterDeclarationExpression.Attributes[i] = o; } nodeStack.Push(parameterDeclarationExpression.TypeReference); parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data); parameterDeclarationExpression.TypeReference = ((TypeReference)(nodeStack.Pop())); nodeStack.Push(parameterDeclarationExpression.DefaultValue); parameterDeclarationExpression.DefaultValue.AcceptVisitor(this, data); parameterDeclarationExpression.DefaultValue = ((Expression)(nodeStack.Pop())); return null; }
private void ParameterArray(out ParameterDeclarationExpression p) { TypeReference reference; base.Expect(0x5e); this.Type(out reference); base.Expect(1); p = new ParameterDeclarationExpression(reference, this.t.val, ParamModifier.Params); }
void ParameterArray( #line 675 "cs.ATG" out ParameterDeclarationExpression p) { #line 676 "cs.ATG" TypeReference type; Expect(95); Type( #line 678 "cs.ATG" out type); Identifier(); #line 678 "cs.ATG" p = new ParameterDeclarationExpression(type, t.val, ParameterModifiers.Params); }
void LambdaExpressionParameter( #line 2101 "cs.ATG" out ParameterDeclarationExpression p) { #line 2102 "cs.ATG" Location start = la.Location; p = null; TypeReference type; if ( #line 2106 "cs.ATG" Peek(1).kind == Tokens.Comma || Peek(1).kind == Tokens.CloseParenthesis) { Identifier(); #line 2108 "cs.ATG" p = new ParameterDeclarationExpression(null, t.val); p.StartLocation = start; p.EndLocation = t.EndLocation; } else if (StartOf(10)) { Type( #line 2111 "cs.ATG" out type); Identifier(); #line 2113 "cs.ATG" p = new ParameterDeclarationExpression(type, t.val); p.StartLocation = start; p.EndLocation = t.EndLocation; } else SynErr(214); }
public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { throw new global::System.NotImplementedException("ParameterDeclarationExpression"); }
/// <summary> /// Creates an argfull stub for the specified implementation method. /// </summary> private MethodDeclaration CreateArgfull(MethodDeclaration template, bool skipThisParams, out bool hasThisParams) { hasThisParams = false; MethodDeclaration method = new MethodDeclaration(template.Name, template.Modifier, new TypeReference("Object"), new List<ParameterDeclarationExpression>(), new List<AttributeSection>()); method.Body = new BlockStatement(); Expression[] arguments = new Expression[template.Parameters.Count]; // prepend a ScriptContext parameter and make all parameters Objects // (TODO: PhpReferences for ref parameters) method.Parameters.Add(new ParameterDeclarationExpression(new TypeReference("ScriptContext"), "__context")); int arg_counter = 0; foreach (ParameterDeclarationExpression param in template.Parameters) { ParameterDeclarationExpression new_param = new ParameterDeclarationExpression(new TypeReference("Object"), param.ParameterName); bool optional = false; if (Utility.IsDecoratedByAttribute(param.Attributes, Utility.OptionalAttrType)) { AttributeSection section = new AttributeSection(); new_param.Attributes.Add(section); section.Attributes.Add(new ICSharpCode.NRefactory.Parser.AST.Attribute(Utility.OptionalAttrType, null, null)); optional = true; } bool this_param = Utility.IsDecoratedByAttribute(param.Attributes, "PHP.Core.ThisAttribute"); if (this_param) hasThisParams = true; if (this_param && skipThisParams) { arguments[arg_counter++] = new PrimitiveExpression(null, String.Empty); } else { // generate conversion arguments[arg_counter++] = Convertor.ConvertTo( template.Name, new IdentifierExpression(param.ParameterName), param.TypeReference, method.Body, new ReturnStatement(new PrimitiveExpression(null, String.Empty)), Utility.IsDecoratedByAttribute(param.Attributes, "PHP.Core.NullableAttribute") || this_param, optional, arg_counter); method.Parameters.Add(new_param); } } // invoke the template method InvocationExpression invocation = new InvocationExpression(new IdentifierExpression(template.Name), new ArrayList(arguments)); if (template.TypeReference.SystemType == "System.Void") { method.Body.AddChild(new StatementExpression(invocation)); method.Body.AddChild(new ReturnStatement(new PrimitiveExpression(null, String.Empty))); } else method.Body.AddChild(new ReturnStatement(invocation)); if (!hasThisParams || skipThisParams) Utility.MakeNonBrowsable(method); return method; }
void FormalParameter( #line 2642 "VBNET.ATG" out ParameterDeclarationExpression p) { #line 2644 "VBNET.ATG" AttributeSection section; List<AttributeSection> attributes = new List<AttributeSection>(); TypeReference type = null; ParamModifierList mod = new ParamModifierList(this); Expression expr = null; p = null; ArrayList arrayModifiers = null; while (la.kind == 28) { AttributeSection( #line 2653 "VBNET.ATG" out section); #line 2653 "VBNET.ATG" attributes.Add(section); } while (StartOf(35)) { ParameterModifier( #line 2654 "VBNET.ATG" mod); } Identifier(); #line 2655 "VBNET.ATG" string parameterName = t.val; if ( #line 2656 "VBNET.ATG" IsDims()) { ArrayTypeModifiers( #line 2656 "VBNET.ATG" out arrayModifiers); } if (la.kind == 50) { lexer.NextToken(); TypeName( #line 2657 "VBNET.ATG" out type); } #line 2659 "VBNET.ATG" if(type != null) { if (arrayModifiers != null) { if (type.RankSpecifier != null) { Error("array rank only allowed one time"); } else { type.RankSpecifier = (int[])arrayModifiers.ToArray(typeof(int)); } } } else { type = new TypeReference("System.Object", arrayModifiers == null ? null : (int[])arrayModifiers.ToArray(typeof(int))); } if (la.kind == 10) { lexer.NextToken(); Expr( #line 2671 "VBNET.ATG" out expr); } #line 2673 "VBNET.ATG" mod.Check(); p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr); p.Attributes = attributes; }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { curBlock.Add(parameterDeclarationExpression.ParameterName); //print("add parameter ${parameterDeclarationExpression.ParameterName} to block") return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data); }
void FixedParameter( #line 661 "cs.ATG" out ParameterDeclarationExpression p) { #line 663 "cs.ATG" TypeReference type; ParameterModifiers mod = ParameterModifiers.In; Location start = la.Location; if (la.kind == 93 || la.kind == 100) { if (la.kind == 100) { lexer.NextToken(); #line 669 "cs.ATG" mod = ParameterModifiers.Ref; } else { lexer.NextToken(); #line 670 "cs.ATG" mod = ParameterModifiers.Out; } } Type( #line 672 "cs.ATG" out type); Identifier(); #line 672 "cs.ATG" p = new ParameterDeclarationExpression(type, t.val, mod); p.StartLocation = start; p.EndLocation = t.Location; }
public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(ConvType(parameterDeclarationExpression.TypeReference), parameterDeclarationExpression.ParameterName); if (parameterDeclarationExpression.ParamModifier == ParameterModifiers.Params) parameter.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(ParamArrayAttribute)))); parameters.Add(parameter); return parameter; }