internal void Init(INamedTypeSymbol sym, ClassSymbolInfo info) { IsEnum = sym.TypeKind == TypeKind.Enum; IsEntryClass = HasAttribute(sym, "Cs2Lua.EntryAttribute"); IsValueType = sym.IsValueType; IsInnerOfGenericType = IsInnerClassOfGenericType(sym); ExistConstructor = false; ExistStaticConstructor = false; SemanticInfo = sym; ClassSemanticInfo = info; Key = GetFullName(sym); BaseKey = GetFullName(sym.BaseType); if (BaseKey == SymbolTable.PrefixExternClassName("System.Object") || BaseKey == SymbolTable.PrefixExternClassName("System.ValueType")) { BaseKey = string.Empty; } GenericTypeKey = ClassInfo.GetFullNameWithTypeParameters(sym); References.Clear(); IgnoreReferences.Clear(); }
private void Init(IMethodSymbol sym) { MethodSymbol = sym; AssemblySymbol = SymbolTable.Instance.AssemblySymbol;; Args.Clear(); ReturnArgs.Clear(); GenericTypeArgs.Clear(); ClassKey = ClassInfo.GetFullName(sym.ContainingType); GenericClassKey = ClassInfo.GetFullNameWithTypeParameters(sym.ContainingType); IsBasicValueMethod = SymbolTable.IsBasicValueMethod(sym); if ((ClassKey == "UnityEngine.GameObject" || ClassKey == "UnityEngine.Component") && (sym.Name.StartsWith("GetComponent") || sym.Name.StartsWith("AddComponent"))) { IsComponentGetOrAdd = true; } if (sym.IsGenericMethod) { foreach (var arg in sym.TypeArguments) { GenericTypeArgs.Add(arg); } } }
private void Init(IMethodSymbol sym) { MethodSymbol = sym; CheckInvocation(sym); Args.Clear(); ArgConversions.Clear(); ReturnArgs.Clear(); GenericTypeArgs.Clear(); ClassKey = ClassInfo.GetFullName(sym.ContainingType); GenericClassKey = ClassInfo.GetFullNameWithTypeParameters(sym.ContainingType); IsExtensionMethod = sym.IsExtensionMethod && SymbolTable.Instance.IsCs2LuaSymbol(sym); IsBasicValueMethod = SymbolTable.IsBasicValueMethod(sym); IsArrayStaticMethod = ClassKey == SymbolTable.PrefixExternClassName("System.Array") && sym.IsStatic; if ((ClassKey == SymbolTable.PrefixExternClassName("UnityEngine.GameObject") || ClassKey == SymbolTable.PrefixExternClassName("UnityEngine.Component")) && (sym.Name.StartsWith("GetComponent") || sym.Name.StartsWith("AddComponent"))) { IsComponentGetOrAdd = true; } if (sym.IsGenericMethod) { foreach (var arg in sym.TypeArguments) { GenericTypeArgs.Add(arg); } } }
internal static string CalcMethodMangling(IMethodSymbol methodSym) { IAssemblySymbol assemblySym = SymbolTable.Instance.AssemblySymbol; if (null == methodSym) { return(string.Empty); } StringBuilder sb = new StringBuilder(); string name = GetMethodName(methodSym); if (!string.IsNullOrEmpty(name) && name[0] == '.') { name = name.Substring(1); } sb.Append(name); if (SymbolTable.Instance.IsCs2LuaSymbol(methodSym)) { foreach (var param in methodSym.Parameters) { sb.Append("__"); if (param.RefKind == RefKind.Ref) { sb.Append("Ref_"); } else if (param.RefKind == RefKind.Out) { sb.Append("Out_"); } var oriparam = param.OriginalDefinition; if (oriparam.Type.Kind == SymbolKind.ArrayType) { sb.Append("Arr_"); var arrSym = oriparam.Type as IArrayTypeSymbol; string fn; if (arrSym.ElementType.TypeKind == TypeKind.TypeParameter) { fn = ClassInfo.GetFullNameWithTypeParameters(arrSym.ElementType); } else { fn = ClassInfo.GetFullName(arrSym.ElementType); } sb.Append(fn.Replace('.', '_')); } else if (oriparam.Type.TypeKind == TypeKind.TypeParameter) { string fn = ClassInfo.GetFullNameWithTypeParameters(oriparam.Type); sb.Append(fn.Replace('.', '_')); } else { string fn = ClassInfo.GetFullName(oriparam.Type); sb.Append(fn.Replace('.', '_')); } } } return(sb.ToString()); }
internal static int IndexOfTypeParameter(List <ITypeParameterSymbol> tParams, ITypeSymbol t) { string name = ClassInfo.GetFullNameWithTypeParameters(t); for (int i = 0; i < tParams.Count; ++i) { if (name == ClassInfo.GetFullNameWithTypeParameters(tParams[i])) { return(i); } } return(-1); }
internal string NameMangling(IMethodSymbol sym) { string ret = GetMethodName(sym); if (!string.IsNullOrEmpty(ret) && ret[0] == '.') { ret = ret.Substring(1); } string key = ClassInfo.GetFullNameWithTypeParameters(sym.ContainingType); ClassSymbolInfo csi; if (m_ClassSymbols.TryGetValue(key, out csi)) { bool isMangling; csi.SymbolOverloadFlags.TryGetValue(ret, out isMangling); if (isMangling) { ret = CalcMethodMangling(sym); } } return(ret); }
internal void Init(INamedTypeSymbol typeSym, CSharpCompilation compilation, SymbolTable symTable) { if (typeSym.TypeKind == TypeKind.Error) { Logger.Instance.ReportIllegalType(typeSym); return; } IsInterface = typeSym.TypeKind == TypeKind.Interface; foreach (var intf in typeSym.AllInterfaces) { string key = ClassInfo.GetFullName(intf); ClassSymbolInfo isi; if (!symTable.ClassSymbols.TryGetValue(key, out isi)) { isi = new ClassSymbolInfo(); symTable.ClassSymbols.Add(key, isi); isi.Init(intf, compilation, symTable); } } ClassKey = ClassInfo.GetFullName(typeSym); BaseClassKey = ClassInfo.GetFullName(typeSym.BaseType); if (BaseClassKey == "System.Object" || BaseClassKey == "System.ValueType") { BaseClassKey = string.Empty; } ExistConstructor = false; ExistStaticConstructor = false; if (typeSym.GetAttributes().Length > 0) { ExistAttributes = true; } bool fieldUseExplicitTypeParams = false; bool staticUseExplicitTypeParams = false; TypeSymbol = typeSym; foreach (var sym in TypeSymbol.GetMembers()) { var fsym = sym as IFieldSymbol; if (null != fsym) { FieldSymbols.Add(fsym); if (fsym.GetAttributes().Length > 0) { ExistAttributes = true; } CheckFieldUseExplicitTypeParam(fsym, compilation, ref fieldUseExplicitTypeParams, ref staticUseExplicitTypeParams); } } foreach (var sym in TypeSymbol.GetMembers()) { var msym = sym as IMethodSymbol; if (null != msym) { if (msym.MethodKind == MethodKind.Constructor && !msym.IsImplicitlyDeclared) { ExistConstructor = true; } else if (msym.MethodKind == MethodKind.StaticConstructor && !msym.IsImplicitlyDeclared) { ExistStaticConstructor = true; } MethodSymbols.Add(msym); if (msym.GetAttributes().Length > 0) { ExistAttributes = true; } string name = msym.Name; if (name[0] == '.') { name = name.Substring(1); } string manglingName = SymbolTable.CalcMethodMangling(msym, symTable.AssemblySymbol); if (msym.IsExtensionMethod && msym.Parameters.Length > 0) { var targetType = msym.Parameters[0].Type as INamedTypeSymbol; if (null != targetType) { string key = ClassInfo.GetFullNameWithTypeParameters(targetType); ClassSymbolInfo csi; if (!symTable.ClassSymbols.TryGetValue(key, out csi)) { csi = new ClassSymbolInfo(); symTable.ClassSymbols.Add(key, csi); csi.Init(targetType, compilation, symTable); } if (!csi.ExtensionClasses.ContainsKey(ClassKey)) { csi.ExtensionClasses.Add(ClassKey, typeSym); csi.GenerateBasicCtor = true; } bool needMangling; bool isOverloaded; if (csi.SymbolOverloadFlags.TryGetValue(name, out isOverloaded)) { if (csi.MethodNames.Contains(manglingName)) { continue; } csi.SymbolOverloadFlags[name] = true; needMangling = true; } else { if (SymbolOverloadFlags.TryGetValue(name, out isOverloaded)) { csi.SymbolOverloadFlags.Add(name, true); needMangling = true; } else { csi.SymbolOverloadFlags.Add(name, false); needMangling = false; } } if (needMangling) { csi.MethodNames.Add(manglingName); SymbolOverloadFlags[name] = true; MethodNames.Add(manglingName); } else { SymbolOverloadFlags.Add(name, false); MethodNames.Add(name); } } } else { if (!SymbolOverloadFlags.ContainsKey(name)) { SymbolOverloadFlags.Add(name, false); MethodNames.Add(name); } else { SymbolOverloadFlags[name] = true; MethodNames.Add(manglingName); } } continue; } var psym = sym as IPropertySymbol; if (null != psym && !psym.IsIndexer) { PropertySymbols.Add(psym); if (psym.GetAttributes().Length > 0) { ExistAttributes = true; } continue; } var esym = sym as IEventSymbol; if (null != esym) { EventSymbols.Add(esym); if (esym.GetAttributes().Length > 0) { ExistAttributes = true; } continue; } } BuildInterfaceInfo(typeSym, compilation, symTable); }
private void VisitTypeDeclarationSyntax(TypeDeclarationSyntax node) { INamedTypeSymbol declSym = m_Model.GetDeclaredSymbol(node); SymbolTable.Instance.AddGenericTypeDefine(ClassInfo.GetFullNameWithTypeParameters(declSym), node); }