public void SetInheritance(ClassSymbol baseClass, ICollection <InterfaceSymbol> interfaces)
{
// Inheritance should only be assigned to a primary partial class.
Debug.Assert(primaryPartialClass == null);
this.baseClass = baseClass;
this.interfaces = interfaces;
}
public IndexerSymbol GetIndexer()
{
if (primaryPartialClass != null)
{
return(primaryPartialClass.GetIndexer());
}
ClassSymbol classSymbol = this;
IndexerSymbol indexer = classSymbol.Indexer;
while (indexer == null)
{
classSymbol = (ClassSymbol)classSymbol.GetBaseType();
if (classSymbol == null)
{
break;
}
indexer = classSymbol.Indexer;
}
return(indexer);
}
private TypeSymbol CreateArrayTypeCore(TypeSymbol itemTypeSymbol)
{
TypeSymbol arrayTypeSymbol =
(TypeSymbol)((ISymbolTable)SystemNamespace).FindSymbol("Array", null, SymbolFilter.Types);
Debug.Assert(arrayTypeSymbol != null);
TypeSymbol specificArrayTypeSymbol = new ClassSymbol("Array", SystemNamespace);
foreach (MemberSymbol memberSymbol in arrayTypeSymbol.Members)
{
specificArrayTypeSymbol.AddMember(memberSymbol);
}
IndexerSymbol indexerSymbol = new IndexerSymbol(specificArrayTypeSymbol, itemTypeSymbol,
MemberVisibility.Public);
indexerSymbol.SetScriptIndexer();
specificArrayTypeSymbol.AddMember(indexerSymbol);
specificArrayTypeSymbol.SetIgnoreNamespace();
specificArrayTypeSymbol.SetNativeArray();
return(specificArrayTypeSymbol);
}
private TypeSymbol CreateGenericTypeCore(TypeSymbol templateType, IList <TypeSymbol> typeArguments)
{
if (templateType.Type == SymbolType.Delegate)
{
DelegateSymbol genericDelegate = (DelegateSymbol)templateType;
DelegateSymbol instanceDelegate =
new DelegateSymbol(genericDelegate.Name, (NamespaceSymbol)genericDelegate.Parent);
instanceDelegate.AddGenericParameters(genericDelegate.GenericParameters);
instanceDelegate.AddGenericArguments(genericDelegate, typeArguments);
CreateGenericTypeMembers(genericDelegate, instanceDelegate, typeArguments);
return(instanceDelegate);
}
if (templateType.Type == SymbolType.Class ||
templateType.Type == SymbolType.Interface)
{
TypeSymbol genericCoreType = null;
TypeSymbol instanceCoreType = null;
if (templateType.Type == SymbolType.Class)
{
ClassSymbol genericClass = (ClassSymbol)templateType;
ClassSymbol instanceClass = new ClassSymbol(genericClass.Name, (NamespaceSymbol)genericClass.Parent);
instanceClass.SetInheritance(genericClass.BaseClass, genericClass.Interfaces);
genericCoreType = genericClass;
instanceCoreType = instanceClass;
}
else if (templateType.Type == SymbolType.Interface)
{
InterfaceSymbol genericInterface = (InterfaceSymbol)templateType;
InterfaceSymbol instanceInterface =
new InterfaceSymbol(genericInterface.Name, (NamespaceSymbol)genericInterface.Parent);
instanceInterface.SetInheritance(genericInterface.Interfaces);
genericCoreType = genericInterface;
instanceCoreType = instanceInterface;
}
instanceCoreType.SetImported(genericCoreType.Dependency);
if (genericCoreType.IgnoreNamespace)
{
instanceCoreType.SetIgnoreNamespace();
}
instanceCoreType.ScriptNamespace = genericCoreType.ScriptNamespace;
if (genericCoreType.IsTransformed)
{
instanceCoreType.SetTransformedName(genericCoreType.GeneratedName);
}
else if (genericCoreType.IsTransformAllowed == false)
{
instanceCoreType.DisableNameTransformation();
}
if (genericCoreType.IsNativeArray)
{
instanceCoreType.SetNativeArray();
}
instanceCoreType.AddGenericParameters(genericCoreType.GenericParameters);
instanceCoreType.AddGenericArguments(genericCoreType, typeArguments);
CreateGenericTypeMembers(genericCoreType, instanceCoreType, typeArguments);
return(instanceCoreType);
}
return(null);
}
private string TransformMember(MemberSymbol memberSymbol)
{
if (memberSymbol.InterfaceMember != null ||
memberSymbol.Name.Length < 3 ||
memberSymbol.IsTransformAllowed == false)
{
// Interface members do get obfuscated
// Also members with already short names do not get
// obfuscated, as doing so might infact increase the name size
return(null);
}
TypeSymbol type = (TypeSymbol)memberSymbol.Parent;
if (memberSymbol.IsPublic == false)
{
if (memberSymbol is CodeMemberSymbol &&
((CodeMemberSymbol)memberSymbol).IsOverride)
{
ClassSymbol baseType = ((ClassSymbol)type).BaseClass;
if (baseType == null)
{
baseType =
(ClassSymbol)((ISymbolTable)memberSymbol.SymbolSet.SystemNamespace).FindSymbol("Object",
null, SymbolFilter.Types);
Debug.Assert(baseType != null);
}
MemberSymbol baseMember =
(MemberSymbol)((ISymbolTable)baseType).FindSymbol(memberSymbol.Name, type,
SymbolFilter.Members);
Debug.Assert(baseMember != null);
return(baseMember.GeneratedName);
}
int minimizationDepth = 0;
int currentCount = -1;
if (type is ClassSymbol)
{
currentCount = ((ClassSymbol)type).TransformationCookie;
}
else if (type is EnumerationSymbol)
{
currentCount = ((EnumerationSymbol)type).TransformationCookie;
}
if (type is ClassSymbol)
{
minimizationDepth = ((ClassSymbol)type).MinimizationDepth;
if (currentCount == -1)
{
ClassSymbol baseClass = ((ClassSymbol)type).BaseClass;
if (baseClass != null && baseClass.IsApplicationType)
{
// Set current count to the base classes transformation
// cookie, so the generated one will the next one in
// sequence
currentCount = baseClass.TransformationCookie;
}
}
}
currentCount++;
if (type is ClassSymbol)
{
((ClassSymbol)type).TransformationCookie = currentCount;
}
else if (type is EnumerationSymbol)
{
((EnumerationSymbol)type).TransformationCookie = currentCount;
}
return(GenerateName(currentCount, minimizationDepth));
}
return(null);
}
