private void AddMember(UField field, string name, bool isResolvedName) { CollapsedMember collapsedMember = null; UProperty property = field as UProperty; if (property != null) { structInfo.collapsedMembersByProperty.TryGetValue(property, out collapsedMember); } UFunction function = field as UFunction; if (function != null) { structInfo.collapsedMembersByFunction.TryGetValue(function, out collapsedMember); } if (collapsedMember != null) { if (isResolvedName) { collapsedMember.ResolvedName = name; } else { name = collapsedMember.Name; } } NameConflictFieldInfo fieldInfo; if (!MembersByName.TryGetValue(name, out fieldInfo)) { MembersByName.Add(name, fieldInfo = new NameConflictFieldInfo(name)); } fieldInfo.AddField(field, collapsedMember); }
private void ResolveNameConflicts() { List <NameConflictInfo> baseConflictInfos = new List <NameConflictInfo>(); UStruct parentStruct = Struct.GetSuperStruct(); if (parentStruct != null) { StructInfo parentInfo = codeGenerator.GetStructInfo(parentStruct); if (parentInfo != null && parentInfo.conflictInfo != null) { baseConflictInfos.Add(parentInfo.conflictInfo); } } if (Class != null) { foreach (FImplementedInterface implementedInterface in Class.Interfaces) { UClass interfaceClass = implementedInterface.InterfaceClass; if (interfaceClass != null) { StructInfo interfaceInfo = codeGenerator.GetStructInfo(interfaceClass); if (interfaceInfo != null && interfaceInfo.conflictInfo != null) { baseConflictInfos.Add(interfaceInfo.conflictInfo); } } } } conflictInfo = new NameConflictInfo(this); foreach (KeyValuePair <UProperty, string> property in exportableProperties) { conflictInfo.AddMember(property.Key, codeGenerator.GetMemberName(property.Key, false, property.Value)); } foreach (UFunction function in exportableFunctions) { // Functions are a special case. They can be redefined in the hierarchy but for name resolving // we want them to have the same name throughout. Therefore only resolve the base-most function // name (even if redefined later in the hierarchy). Then when we do a name conflict lookup find that // base-most function and use that name for all of the functions in the hierarchy with that name. // - This is lookup is done in ResolveNameConflict(). if (codeGenerator.GetOriginalFunctionOwner(function) == Class) { conflictInfo.AddMember(function, codeGenerator.GetFunctionName(function, false)); } } foreach (NameConflictInfo baseConflictInfo in baseConflictInfos) { foreach (KeyValuePair <string, NameConflictFieldInfo> baseMembersByName in baseConflictInfo.MembersByName) { NameConflictFieldInfo baseMembers; if (!conflictInfo.BaseMembersByName.TryGetValue(baseMembersByName.Key, out baseMembers)) { conflictInfo.BaseMembersByName.Add(baseMembersByName.Key, baseMembers = new NameConflictFieldInfo(baseMembersByName.Key)); } foreach (KeyValuePair <UField, CollapsedMember> baseMember in baseMembersByName.Value.Fields) { baseMembers.AddField(baseMember.Key, baseMember.Value); } } foreach (KeyValuePair <string, NameConflictFieldInfo> baseBaseMembersByName in baseConflictInfo.BaseMembersByName) { NameConflictFieldInfo baseBaseMembers; if (!conflictInfo.BaseMembersByName.TryGetValue(baseBaseMembersByName.Key, out baseBaseMembers)) { conflictInfo.BaseMembersByName.Add(baseBaseMembersByName.Key, baseBaseMembers = new NameConflictFieldInfo(baseBaseMembersByName.Key)); } foreach (KeyValuePair <UField, CollapsedMember> baseBaseMember in baseBaseMembersByName.Value.Fields) { baseBaseMembers.AddField(baseBaseMember.Key, baseBaseMember.Value); } } } var tempMembersByName = new Dictionary <string, NameConflictFieldInfo>(conflictInfo.MembersByName); foreach (KeyValuePair <string, NameConflictFieldInfo> membersByName in tempMembersByName) { // What about overridden functions? where do they appear? if (membersByName.Value.HasConflict() || conflictInfo.BaseMembersByName.ContainsKey(membersByName.Key)) { foreach (KeyValuePair <UField, CollapsedMember> field in membersByName.Value.Fields) { if (field.Value == null) { string hashedName = membersByName.Key + "_" + field.Key.GetPathName().GetHashCode().ToString("X8"); NameConflictResolved(field.Key, hashedName); } } foreach (KeyValuePair <CollapsedMember, List <UField> > collapsedMember in membersByName.Value.FieldsByCollapsedMember) { UField field = null; if (collapsedMember.Key.Getter != null) { field = collapsedMember.Key.Getter; } else if (collapsedMember.Key.Setter != null) { field = collapsedMember.Key.Setter; } else if (collapsedMember.Key.BackingProperty != null) { field = collapsedMember.Key.BackingProperty; } string hashedName = membersByName.Key + "_" + field.GetPathName().GetHashCode().ToString("X8"); if (collapsedMember.Key.Getter != null) { NameConflictResolved(collapsedMember.Key.Getter, hashedName); } if (collapsedMember.Key.Setter != null) { NameConflictResolved(collapsedMember.Key.Setter, hashedName); } if (collapsedMember.Key.BackingProperty != null) { NameConflictResolved(collapsedMember.Key.BackingProperty, hashedName); } } // All fields with this name should have been renamed. Remove the old name. conflictInfo.MembersByName.Remove(membersByName.Key); } } }