private static void GenerateNamedParametersValue(ActionModel action, FunctionMember method) { var namedParameters = action.Parameters.Where(x => !x.IsUrlParam && !x.IsData).ToArray(); if (namedParameters.Length == 0) { method.Body.Statements.Add("{}"); return; } //this optimalization cannot be done due to renaming params signature=>urlName //if (namedParameters.All(p => p.IsOptional)) //{ // method.Body.Statements.Add("opt"); // return; //} var pilist = new List <string>(); foreach (var p in namedParameters) { var pinvoke = "'" + (p.UrlName ?? p.Name) + "': "; pinvoke += p.IsOptional ? ("opt['" + p.Name + "']") : p.Name; pilist.Add(pinvoke); } method.Body.Statements.Add("{ "); method.Body.Statements.Add(String.Join(", ", pilist)); method.Body.Statements.Add(" }"); }
public virtual void VisitFunctionMember(FunctionMember fn) { VisitFunctionMemberBase(fn); if (fn.Body != null) { VisitRaw(fn.Body); } }
public virtual FunctionMember RewriteFunctionMember(FunctionMember fn) { var result = new FunctionMember(fn.Name, RewriteRaw(fn.Body)) { Accessibility = RewriteAccessibility(fn.Accessibility), Comment = RewriteComment(fn.Comment), ExtraData = RewriteExtraData(fn), ResultType = RewriteTypeReference(fn.ResultType), }; result.GenericParameters.AddRange(fn.GenericParameters.Select(RewriteGenericParameter).Where(x => x != null)); result.Parameters.AddRange(fn.Parameters.Select(RewriteFunctionParameter).Where(x => x != null)); return(result); }
private static void GenerateUrlParametersValue(ActionModel action, FunctionMember method) { var urlVar = "'" + action.UrlTemplate.TrimEnd('/') + "'"; foreach (var p in action.Parameters.Where(x => x.IsUrlParam)) { var paramName = p.UrlName ?? p.Name; urlVar = urlVar.Replace("{" + paramName + "}", "' + " + p.Name + " + '"); } var EMPTYJS = " + ''"; while (urlVar.EndsWith(EMPTYJS, StringComparison.InvariantCulture)) { urlVar = urlVar.Substring(0, urlVar.Length - EMPTYJS.Length); } method.Body.Statements.Add(urlVar); }
private static void GenerateMethodParametersSignature(ActionModel action, FunctionMember method, ReflectionGeneratorBase reflectionGenerator) { method.Parameters.AddRange(action.Parameters .Where(p => !p.IsOptional) .Select(p => new FunctionParameter(p.Name) { ParameterType = reflectionGenerator.GenerateFromType(p.Type), IsOptional = false })); //consider: // if there is only one optional parameter, or all opt. parameters are last (it must be in c# decl), // we can generate myMethod(p1,p2,..., po1:string? = null, po2:number? = null) // but, it is needed then to call it with positional params (TypeScript doesn't know named params) // xxx.myMethod("asd","qwe",...,null, 42) //compare to: call via optional properties of anonymous object // xxx.myMethod("asd","qwe",..., { po2: 42} ) // BUT, it can be called with any object, because all positional parameters are optional, so any object will match // xxx.myMethod("asd","qwe",..., "nonsense" ) // partially solved: // positional parameters are unions of non-nullable parameter objects (see code) // but this approach will still validate only one of parameters, others are than ignored (because at least one matched) if (action.Parameters.Any(p => p.IsOptional)) { var optParams = action.Parameters .Where(p => p.IsOptional) .Select(p => new RawStatements("{ ", p.Name, ": ", reflectionGenerator.GenerateFromType(p.Type), " }")) .ToArray(); var raw = new RawStatements(); foreach (var item in optParams) { raw.Add(item); if (item != optParams.Last()) { raw.Add(" | "); } raw.Add(" "); } raw.Add(" = <any>{}"); method.Parameters.Add(new FunctionParameter("opt") { ParameterType = new TypescriptTypeReference(raw) }); } }
private FunctionMember GenerateAction(ActionModel action, ReflectionGeneratorBase reflectionGenerator) { var method = new FunctionMember(action.Name + "Async", null) { Accessibility = AccessibilityEnum.Public, Comment = GenerateActionComment(action) }; GenerateMethodParametersSignature(action, method, reflectionGenerator); if (action.ResultType != null) { method.ResultType = new TypescriptTypeReference(PromiseTypeName) { GenericParameters = { reflectionGenerator.GenerateFromType(action.ResultType) } }; } else { method.ResultType = new TypescriptTypeReference(PromiseTypeName) { GenericParameters = { PrimitiveType.Void } }; } method.Body = new RawStatements(); method.Body.Statements.Add("return this._parent.call" + action.HttpMethod + "("); GenerateUrlParametersValue(action, method); method.Body.Statements.Add(", "); GenerateNamedParametersValue(action, method); var dataParam = action.Parameters.FirstOrDefault(p => p.IsData); if (dataParam != null) { method.Body.Statements.Add(", " + dataParam.Name); if (dataParam.IsData) { method.Body.Statements.Add("/* DATA */"); } } method.Body.Statements.Add(");"); return(method); }
public object GetValue(object[] args = null) { if (FieldMember != null) { return(FieldMember.GetValue(ReferencedObject)); } if (PropertyMember != null) { return(PropertyMember.GetValue(ReferencedObject, null)); } if (FunctionMember != null) { return(FunctionMember.Invoke(FunctionMember.IsStatic ? null : ReferencedObject, args)); } if (FunctionOverloads != null) { throw new Exception("!!"); } return(ReferencedObject); }
public void TestFunctions() { var cls = new ClassType("testFunctions"); { var fn = new FunctionDeclarationMember("fn1"); cls.Members.Add(fn); } { var fn = new FunctionDeclarationMember("fn2") { ResultType = new ArrayType(cls) }; cls.Members.Add(fn); } { var fn = new FunctionDeclarationMember("fn3") { Parameters = { new FunctionParameter("a") { ParameterType = PrimitiveType.Number }, new FunctionParameter("b") { ParameterType = PrimitiveType.Boolean, IsOptional = true }, new FunctionParameter("c"), new FunctionParameter("d") { IsRest = true, ParameterType = new ArrayType(PrimitiveType.String) }, } }; cls.Members.Add(fn); } { var fn = new FunctionDeclarationMember("fn4") { GenericParameters = { new GenericParameter("T"), new GenericParameter("T2") { Constraint = cls }, }, Parameters = { new FunctionParameter("p1") { ParameterType = new TypescriptTypeReference("T2") }, } }; cls.Members.Add(fn); } { var fn = new FunctionMember("fn5", new RawStatements("return true;")) { Parameters = { new FunctionParameter("arg") { ParameterType = PrimitiveType.Boolean } }, }; cls.Members.Add(fn); } { var fn = new FunctionMember("fn6", null) { Parameters = { new FunctionParameter("arg") { ParameterType = PrimitiveType.String, DefaultValue = new RawStatements("'42'") } }, }; cls.Members.Add(fn); } Assert.AreEqual(@" class testFunctions { fn1(); fn2(): testFunctions[]; fn3(a: number, b?: boolean, c, ...d: string[]); fn4<T, T2 extends testFunctions>(p1: T2); fn5(arg: boolean) { return true; } fn6(arg: string = '42') { } } ".Trim(), testGen(cls)); }