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);
}
