private TSMemberDescription ToEnumeratorConstructorDescription(KeyValuePair <TSSimpleType, string> kvp) { var collectionTypeName = kvp.Key; var itemTypeName = kvp.Value; var ret = new TSMemberDescription(); ret.AddParameter("col", collectionTypeName); ret.ReturnType = ParseTypeName($"Enumerator<{itemTypeName}>"); return(ret); }
private TSMemberDescription ToMemberDescription(ParameterizedSetterInfo x) { var ret = new TSMemberDescription(); ret.AddParameter("obj", x.objectType); ret.AddParameter("propertyName", $"'{x.propertyName}'"); ret.AddParameter("parameterTypes", x.parameterTypes); ret.AddParameter("newValue", x.valueType); ret.ReturnType = TSSimpleType.Void; return(ret); }
private Dictionary <string, TSMemberDescription> GetMembers(Members members, ref string enumerableType, string typename) { var membersList = members.Cast().ToList(); TSMemberDescription defaultProperty = null; var ret = membersList.Where(x => !x.IsRestricted() && x.Name != "_NewEnum").ToLookup(x => x.Name).Select(grp => { var memberKVP = KVP(grp.Key, GetMemberDescriptionForName(grp, typename)); var defaultMember = grp.Where(x => x.MemberId == 0).ToList(); if (!memberKVP.Value.IsProperty && defaultMember.Any()) { if (grp.Count() != defaultMember.Count) { throw new Exception("Default and non-default properties on the same name"); } if (defaultProperty != null) { throw new Exception("Multiple default properties in 'members'"); } defaultProperty = memberKVP.Value; } return(memberKVP); }).ToDictionary(); if (defaultProperty != null) { ret.Add("", defaultProperty); } var enumerableType1 = enumerableType; //because ref parameters cannot be used within lambda expressions membersList.ToLookup(x => x.Name).IfContainsKey("_NewEnum", mi => { ret.IfContainsKey("Item", itemMI => enumerableType1 = ((TSSimpleType)itemMI.ReturnType).FullName); }); // there is an overload of EnumeratorConstructor that accepts anything with an Item member, and resolves the enumerator type to the return type of Item var lookup = ret.WhereKVP((name, descr) => name == "Item").ToLookup(kvp => kvp.Value.ReturnType); if (lookup.Count == 1) { enumerableType1 = null; } enumerableType = enumerableType1; return(ret); }
//ActiveXObject.on(obj: 'Word.Application', 'BeforeDocumentSave', ['Doc','SaveAsUI','Cancel'], function (params) {}); private TSMemberDescription ToActiveXEventMember(MemberInfo m, CoClassInfo c) { var @namespace = c.Parent.Name; var eventName = m.Name; var args = m.Parameters.Cast().Select(x => KVP(x.Name, (type: GetTypeName(x.VarTypeInfo, true), @readonly: !x.IsByRef()))).ToList(); ITSType argnamesType; ITSType parameterType; if (args.None()) { argnamesType = null; parameterType = TSObjectType.PlainObject; } else if (args.Count <= 5) { argnamesType = new TSTupleType(args.Keys().Select(x => $"'{x}'")); parameterType = new TSObjectType(args); } else { var alias = new TSAliasDescription() { TargetType = new TSTupleType(args.Keys().Select(x => $"'{x}'")) }; var param = new TSInterfaceDescription(); args.SelectKVP((key, value) => KVP(key, new TSMemberDescription() { ReturnType = value.type, ReadOnly = value.@readonly })).AddRangeTo(param.Members); var helperTypeKey = $"{@namespace}.EventHelperTypes.{c.Name}_{eventName}"; if (!eventHelperTypes.TryGetValue(helperTypeKey, out var helperTypes)) { helperTypes = (alias, param); eventHelperTypes.Add(helperTypeKey, helperTypes); } else if (!helperTypes.argNamesType.Equals(alias) || !helperTypes.parameterType.Equals(param)) { Debugger.Break(); } argnamesType = (TSSimpleType)$"{@namespace}.EventHelperTypes.{c.Name}_{eventName}_ArgNames"; parameterType = (TSSimpleType)$"{@namespace}.EventHelperTypes.{c.Name}_{eventName}_Parameter"; } var eventsourceType = $"{@namespace}.{c.Name}"; var ret = new TSMemberDescription(); ret.AddParameter("obj", $"{eventsourceType}"); ret.AddParameter("event", $"'{eventName}'"); if (argnamesType != null) { ret.AddParameter("argNames", argnamesType); } //build the handler parameter type var memberDescr = new TSMemberDescription(); var fnType = new TSFunctionType(memberDescr); memberDescr.AddParameter("this", eventsourceType); memberDescr.AddParameter("parameter", parameterType); memberDescr.ReturnType = TSSimpleType.Void; ret.AddParameter("handler", fnType); ret.ReturnType = TSSimpleType.Void; return(ret); }
private TSMemberDescription GetMemberDescriptionForName(IEnumerable <MemberInfo> members, string typename) { var ret = new TSMemberDescription(); var parameterList = GetSingleParameterList(members, ret.JsDoc); var paramType = Standard; parameterList.ForEachKVP((name, p) => { if (p.ParameterType == Standard && paramType == Optional) { p.ParameterType = Optional; } paramType = p.ParameterType; }); var memberCount = members.Count(); bool hasSetter = false; if (memberCount > 1) { if (!members.All(x => x.IsProperty())) { throw new InvalidOperationException("Unable to parse single name with property and non-property members"); } if (memberCount.In(2, 3)) { //readwrite properties will have multiple members - one getter and one setter; setters can also be either Set or Let (simple assignment) bool hasGetter = members.Any(m => m.InvokeKind == INVOKE_PROPERTYGET); hasSetter = members.Any(m => m.InvokeKind.In(INVOKE_PROPERTYPUT, INVOKE_PROPERTYPUTREF)); if (!hasGetter || !hasSetter) { throw new InvalidOperationException("Unable to parse multiple getters or multiple setter."); } } else { throw new InvalidOperationException("Unable to parse multiple getters or multiple setter."); } } var invokeable = members.First().IsInvokeable(); if (members.Any(x => x.IsInvokeable() != invokeable)) { throw new InvalidOperationException("Invokeable and non-invokeable members with the same name."); } invokeable = invokeable || (parameterList != null && parameterList.Any()); if (invokeable) { ret.Parameters = parameterList ?? new List <KeyValuePair <string, TSParameterDescription> >(); } if (!invokeable) { ret.ReadOnly = !hasSetter; } ret.ReturnType = GetTypeName(members.First().ReturnType, !invokeable); if (hasSetter && parameterList.Any()) { var parameterTypes = new TSTupleType(); parameterList.SelectKVP((name, parameterDescription) => parameterDescription.Type).AddRangeTo(parameterTypes.Members); parameterizedSetters.Add(new ParameterizedSetterInfo() { objectType = new TSSimpleType(typename), propertyName = members.First().Name, parameterTypes = parameterTypes, valueType = (TSSimpleType)ret.ReturnType }); } ret.JsDoc.Add("", members.Select(x => x.HelpString).Distinct().Joined(" / ")); return(ret); }