public override BoundNode VisitMethodInfo(BoundMethodInfo node)
{
var rewrittenMethod = VisitMethodSymbol(node.Method);
// No need to rewrite the node's type, because it is always System.Reflection.MethodInfo
return(node.Update(rewrittenMethod, node.GetMethodFromHandle, node.Type));
}
private Dictionary <string, object> GenerateMethod(BoundMethodInfo bmi)
{
var res = GenerateFunction(bmi.Function);
if (bmi.Instance != null && bmi.Instance.TypeId != BuiltinTypeId.NoneType)
{
res["bound"] = true;
}
return(res);
}
private void EmitMethodInfoExpression(BoundMethodInfo node)
{
_builder.EmitOpCode(ILOpCode.Ldtoken);
EmitSymbolToken(node.Method, node.Syntax, null);
MethodSymbol getMethod = node.GetMethodFromHandle;
Debug.Assert((object)getMethod != null);
if (getMethod.ParameterCount == 1)
{
_builder.EmitOpCode(ILOpCode.Call, stackAdjustment: 0); //argument off, return value on
}
else
{
Debug.Assert(getMethod.ParameterCount == 2);
_builder.EmitOpCode(ILOpCode.Ldtoken);
EmitSymbolToken(node.Method.ContainingType, node.Syntax);
_builder.EmitOpCode(ILOpCode.Call, stackAdjustment: -1); //2 arguments off, return value on
}
EmitSymbolToken(getMethod, node.Syntax, null);
if (node.Type != getMethod.ReturnType)
{
_builder.EmitOpCode(ILOpCode.Castclass);
EmitSymbolToken(node.Type, node.Syntax);
}
}
public override BoundNode VisitMethodInfo(BoundMethodInfo node)
{
var rewrittenMethod = VisitMethodSymbol(node.Method);
// No need to rewrite the node's type, because it is always System.Reflection.MethodInfo
return node.Update(rewrittenMethod, node.GetMethodFromHandle, node.Type);
}
private object GetMemberValueInternal(AnalysisValue type, ModuleInfo declModule, bool isRef)
{
SpecializedNamespace specialCallable = type as SpecializedNamespace;
if (specialCallable != null)
{
if (specialCallable.Original == null)
{
return(null);
}
return(GetMemberValueInternal(specialCallable.Original, declModule, isRef));
}
switch (type.MemberType)
{
case PythonMemberType.Function:
FunctionInfo fi = type as FunctionInfo;
if (fi != null)
{
if (fi.DeclaringModule.GetModuleInfo() != declModule)
{
return(GenerateFuncRef(fi));
}
else
{
return(GenerateFunction(fi));
}
}
BuiltinFunctionInfo bfi = type as BuiltinFunctionInfo;
if (bfi != null)
{
return(GenerateFuncRef(bfi));
}
return("function");
case PythonMemberType.Method:
BoundMethodInfo mi = type as BoundMethodInfo;
if (mi != null)
{
return(GenerateMethod(mi));
}
return("method");
case PythonMemberType.Property:
FunctionInfo prop = type as FunctionInfo;
if (prop != null)
{
return(GenerateProperty(prop));
}
break;
case PythonMemberType.Class:
ClassInfo ci = type as ClassInfo;
if (ci != null)
{
if (isRef || ci.DeclaringModule.GetModuleInfo() != declModule)
{
// TODO: Save qualified name so that classes defined in classes/function can be resolved
return(GetTypeRef(ci.DeclaringModule.ModuleName, ci.Name));
}
else
{
return(GenerateClass(ci, declModule));
}
}
BuiltinClassInfo bci = type as BuiltinClassInfo;
if (bci != null)
{
return(GetTypeRef(bci.PythonType.DeclaringModule.Name, bci.PythonType.Name));
}
return("type");
case PythonMemberType.Constant:
ConstantInfo constantInfo = type as ConstantInfo;
if (constantInfo != null)
{
return(GenerateConstant(constantInfo));
}
break;
case PythonMemberType.Module:
if (type is ModuleInfo)
{
return(GetModuleName(((ModuleInfo)type).Name));
}
else if (type is BuiltinModule)
{
return(GetModuleName(((BuiltinModule)type).Name));
}
break;
case PythonMemberType.Instance:
return(new Dictionary <string, object> {
{ "type", GenerateTypeName(type, true) }
});
default:
return(new Dictionary <string, object>()
{
{ "type", GenerateTypeName(type.PythonType) }
});
}
return(null);
}
private object GetMemberValue(Namespace type, bool isRef)
{
switch (type.ResultType)
{
case PythonMemberType.Function:
FunctionInfo fi = type as FunctionInfo;
if (fi != null)
{
return(GenerateFunction(fi));
}
BuiltinFunctionInfo bfi = type as BuiltinFunctionInfo;
if (bfi != null)
{
return(GenerateFunction(bfi));
}
return("function");
case PythonMemberType.Method:
BoundMethodInfo mi = type as BoundMethodInfo;
if (mi != null)
{
return(GenerateFunction(mi.Function));
}
return("method");
case PythonMemberType.Property:
FunctionInfo prop = type as FunctionInfo;
if (prop != null)
{
return(GenerateProperty(prop));
}
break;
case PythonMemberType.Class:
ClassInfo ci = type as ClassInfo;
if (ci != null)
{
if (isRef)
{
return(GenerateClassRef(ci));
}
else
{
return(GenerateClass(ci));
}
}
BuiltinClassInfo bci = type as BuiltinClassInfo;
if (bci != null)
{
return(GenerateClassRef(bci));
}
return("type");
case PythonMemberType.Constant:
ConstantInfo constantInfo = type as ConstantInfo;
if (constantInfo != null)
{
return(GenerateConstant(constantInfo));
}
break;
case PythonMemberType.Module:
if (type is ModuleInfo)
{
return(new Dictionary <string, object>()
{
{ "module_name", ((ModuleInfo)type).Name }
});
}
else if (type is BuiltinModule)
{
return(new Dictionary <string, object>()
{
{ "module_name", ((BuiltinModule)type).Name }
});
}
break;
case PythonMemberType.Instance:
InstanceInfo instInfo = type as InstanceInfo;
if (instInfo != null)
{
return(new Dictionary <string, object>()
{
{ "type", GenerateTypeName(instInfo.ClassInfo) }
});
}
SequenceInfo seqInfo = type as SequenceInfo;
if (seqInfo != null)
{
return(new Dictionary <string, object>()
{
{ "type", GenerateTypeName(seqInfo.ClassInfo) }
});
}
break;
default:
return(new Dictionary <string, object>()
{
{ "type", GenerateTypeName(type.PythonType) }
});
}
return(null);
}
