private bool CheckConvert(ITypeSymbol srcTypeSym, ITypeSymbol targetTypeSym)
{
var srcNamedTypeSym = srcTypeSym as INamedTypeSymbol;
var targetNamedTypeSym = targetTypeSym as INamedTypeSymbol;
SymbolTable.TryRemoveNullable(ref srcNamedTypeSym);
SymbolTable.TryRemoveNullable(ref targetNamedTypeSym);
if (null != srcNamedTypeSym && null != targetNamedTypeSym)
{
if (null != srcNamedTypeSym.ContainingType && SymbolTable.CalcFullNameWithTypeParameters(srcNamedTypeSym, true) == "System.Object" && SymbolTable.Instance.IsExternSymbol(srcNamedTypeSym.ContainingType) && targetNamedTypeSym.TypeKind != TypeKind.Delegate && (targetNamedTypeSym.IsGenericType || !SymbolTable.Instance.IsExternSymbol(targetNamedTypeSym)))
{
if (!SymbolTable.Instance.IsLegalConvertion(srcNamedTypeSym, targetNamedTypeSym))
{
return(false);
}
}
else if (null != targetNamedTypeSym.ContainingType && SymbolTable.CalcFullNameWithTypeParameters(targetNamedTypeSym, true) == "System.Object" && SymbolTable.Instance.IsExternSymbol(targetNamedTypeSym.ContainingType) && srcNamedTypeSym.TypeKind != TypeKind.Delegate && (srcNamedTypeSym.IsGenericType || !SymbolTable.Instance.IsExternSymbol(srcNamedTypeSym)))
{
if (!SymbolTable.Instance.IsLegalConvertion(srcNamedTypeSym, targetNamedTypeSym))
{
return(false);
}
}
else if (srcNamedTypeSym.TypeKind == TypeKind.Delegate || targetNamedTypeSym.TypeKind == TypeKind.Delegate)
{
//delegate之间赋值认为合法
}
else if (!srcNamedTypeSym.IsGenericType && SymbolTable.Instance.IsExternSymbol(srcNamedTypeSym) && targetNamedTypeSym.IsGenericType)
{
if (!SymbolTable.Instance.IsLegalConvertion(srcNamedTypeSym, targetNamedTypeSym))
{
return(false);
}
}
}
if (null != targetNamedTypeSym && SymbolTable.Instance.IsExternSymbol(targetNamedTypeSym) && SymbolTable.Instance.IsIllegalType(targetNamedTypeSym))
{
return(false);
}
return(true);
}
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
var sym = m_Model.GetSymbolInfo(node).Symbol as IMethodSymbol;
var newNode = base.VisitInvocationExpression(node);
if (null != sym && SymbolTable.Instance.IsExternSymbol(sym))
{
var ckey = SymbolTable.CalcFullNameWithTypeParameters(sym.ContainingType, true);
var oper = null != node?m_Model.GetOperation(node) as IInvocationExpression : null;
var realType = null != oper && null != oper.Instance ? oper.Instance.Type : null;
if (sym.IsExtensionMethod && !SymbolTable.Instance.IsLegalExtension(sym.ContainingType))
{
//不支持的语法
newNode = ReportAndAttachError(newNode, "[Cs2LuaRewriter] Unsupported extension method !");
}
else
{
if (SymbolTable.Instance.IsIllegalMethod(sym))
{
newNode = ReportAndAttachError(newNode, "[Cs2LuaRewriter] Unsupported extern method !");
}
}
bool legal = true;
if (sym.ContainingType.TypeKind == TypeKind.Delegate ||
(null == realType || realType == sym.ContainingType) && sym.ContainingType.IsGenericType && SymbolTable.Instance.IsLegalGenericType(sym.ContainingType, true) ||
sym.IsGenericMethod && SymbolTable.Instance.IsLegalGenericMethod(sym))
{
//如果是标记为合法的泛型类或委托类型的成员，则不用再进行类型检查
}
else
{
List <ExpressionSyntax> args;
List <ArgDefaultValueInfo> defArgs;
List <IConversionExpression> argConversions;
ExtractInvocationInfo(sym, node.ArgumentList, out args, out defArgs, out argConversions);
int ix = 0;
foreach (var param in sym.Parameters)
{
IOperation argOper = null;
if (ix < args.Count)
{
argOper = null != args[ix] ? m_Model.GetOperation(args[ix]) : null;
}
else if (ix < args.Count + defArgs.Count)
{
argOper = defArgs[ix - args.Count].OperOrSym as IOperation;
}
IConversionExpression argConv = null;
if (ix < argConversions.Count)
{
argConv = argConversions[ix];
}
++ix;
INamedTypeSymbol argType = null;
if (null != argOper && (null == argConv || !argConv.UsesOperatorMethod))
{
argType = argOper.Type as INamedTypeSymbol;
}
var paramType = param.Type as INamedTypeSymbol;
if (null != paramType && paramType.TypeKind != TypeKind.Delegate)
{
bool isContainerIntf = paramType.Name == "IEnumerable" || paramType.Name == "ICollection" || paramType.Name == "IDictionary" || paramType.Name == "IList";
if (null != realType && !SymbolTable.Instance.IsExternSymbol(realType) && isContainerIntf &&
null != argType && (argType.IsGenericType || !SymbolTable.Instance.IsExternSymbol(argType)))
{
legal = false;
}
else if (paramType.IsGenericType)
{
if (!SymbolTable.Instance.IsLegalParameterGenericType(paramType))
{
legal = false;
}
}
else
{
if (SymbolTable.Instance.IsIllegalType(paramType))
{
legal = false;
}
}
}
}
if (!sym.ReturnsVoid)
{
var type = sym.ReturnType as INamedTypeSymbol;
if (null != type && type.TypeKind != TypeKind.Delegate)
{
if (type.IsGenericType)
{
if (!SymbolTable.Instance.IsLegalParameterGenericType(type))
{
legal = false;
}
}
else
{
if (SymbolTable.Instance.IsIllegalType(type))
{
legal = false;
}
}
}
}
}
if (!legal)
{
newNode = ReportAndAttachError(newNode, string.Format("[Cs2LuaRewriter] Unsupported extern type from invocation's return or params !"));
}
}
return(newNode);
}