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