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