internal static BuiltinClassInfo GetIteratorTypeFromType(BuiltinClassInfo klass, AnalysisUnit unit) { switch (klass.PythonType.TypeId) { case BuiltinTypeId.List: return unit.ProjectState.ClassInfos[BuiltinTypeId.ListIterator]; case BuiltinTypeId.Tuple: return unit.ProjectState.ClassInfos[BuiltinTypeId.TupleIterator]; case BuiltinTypeId.Set: return unit.ProjectState.ClassInfos[BuiltinTypeId.SetIterator]; case BuiltinTypeId.Str: return unit.ProjectState.ClassInfos[BuiltinTypeId.StrIterator]; case BuiltinTypeId.Unicode: return unit.ProjectState.ClassInfos[BuiltinTypeId.UnicodeIterator]; case BuiltinTypeId.Bytes: return unit.ProjectState.ClassInfos[BuiltinTypeId.BytesIterator]; case BuiltinTypeId.Generator: case BuiltinTypeId.DictKeys: case BuiltinTypeId.DictValues: case BuiltinTypeId.DictItems: case BuiltinTypeId.ListIterator: case BuiltinTypeId.TupleIterator: case BuiltinTypeId.SetIterator: case BuiltinTypeId.StrIterator: case BuiltinTypeId.UnicodeIterator: case BuiltinTypeId.BytesIterator: case BuiltinTypeId.CallableIterator: return klass; default: return null; } }
public SequenceBuiltinInstanceInfo(BuiltinClassInfo klass, bool sequenceOfSelf, bool supportsMod) : base(klass) { _supportsMod = supportsMod; var seqInfo = klass as SequenceBuiltinClassInfo; if (seqInfo != null) { _indexTypes = seqInfo.IndexTypes; } else if (sequenceOfSelf) { _indexTypes = SelfSet; } else { _indexTypes = AnalysisSet.Empty; } }
private object GenerateTypeName(AnalysisValue baseClass, bool isRef) { ClassInfo ci = baseClass as ClassInfo; if (ci != null) { return(GetTypeName(((ProjectEntry)ci.DeclaringModule).GetModuleInfo().Name, ci.ClassDefinition.Name)); } BuiltinClassInfo bci = baseClass as BuiltinClassInfo; if (bci != null) { return(GenerateTypeName(bci._type)); } IterableValue iteri = baseClass as IterableValue; if (iteri != null) { return(GenerateTypeName(iteri.PythonType, isRef, iteri.IndexTypes)); } InstanceInfo ii = baseClass as InstanceInfo; if (ii != null) { return(GenerateTypeName(ii.ClassInfo, isRef)); } BuiltinInstanceInfo bii = baseClass as BuiltinInstanceInfo; if (bii != null) { return(GenerateTypeName(bii.ClassInfo, isRef)); } return(GenerateTypeName(baseClass.PythonType)); }
public IterableValue(VariableDef[] indexTypes, BuiltinClassInfo seqType, Node node) : base(seqType) { IndexTypes = indexTypes; _node = node; }
public ListInfo(VariableDef[] indexTypes, BuiltinClassInfo seqType, Node node) : base(indexTypes, seqType, node) { EnsureAppend(); }
public IterBoundBuiltinMethodInfo(IterableInfo iterable, BuiltinMethodInfo method) : base(method) { _indexTypes = iterable.IndexTypes; _iterClass = IteratorInfo.GetIteratorTypeFromType(iterable.ClassInfo, iterable.ClassInfo.ProjectState._evalUnit); }
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); }
public ListInfo(VariableDef[] indexTypes, BuiltinClassInfo seqType, Node node, ProjectEntry entry) : base(indexTypes, seqType, node, entry) { }
public SequenceInfo(VariableDef[] indexTypes, BuiltinClassInfo seqType, Node node, ProjectEntry entry) : base(indexTypes, seqType, node) { _declaringModule = entry; _declaringVersion = entry.AnalysisVersion; }
public IteratorInfo(VariableDef[] indexTypes, BuiltinClassInfo iterType, Node node) : base(indexTypes, iterType, node) { }
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); }
public StarArgsSequenceInfo(VariableDef[] variableDef, BuiltinClassInfo builtinClassInfo, Node node) : base(variableDef, builtinClassInfo, node) { }
public SequenceInfo(VariableDef[] indexTypes, BuiltinClassInfo seqType, Node node) : base(indexTypes, seqType, node) { }
public BaseIteratorValue(BuiltinClassInfo klass) : base(klass) { }
public IteratorValue(IterableValue iterable, BuiltinClassInfo iterType) : base(iterType) { _iterable = iterable; }
public SingleIteratorValue(VariableDef indexTypes, BuiltinClassInfo iterType, IPythonProjectEntry declModule) : base(iterType) { _indexTypes = indexTypes; _declModule = declModule; }
public FixedIteratorValue(IAnalysisSet iterable, BuiltinClassInfo klass) : base(klass) { _iterable = iterable; }
public ProjectState(ScriptEngine pythonEngine) { _pythonEngine = pythonEngine; _projectEntries = new List <ProjectEntry>(); _modules = new Dictionary <string, ModuleReference>(); _modulesByFilename = new Dictionary <string, ModuleInfo>(StringComparer.OrdinalIgnoreCase); _itemCache = new Dictionary <object, object>(); var pythonContext = HostingHelpers.GetLanguageContext(_pythonEngine) as PythonContext; _codeContextCls = new ModuleContext(new PythonDictionary(), pythonContext).GlobalContext; _codeContextCls.ModuleContext.ShowCls = true; _codeContext = new ModuleContext( new PythonDictionary(), HostingHelpers.GetLanguageContext(_pythonEngine) as PythonContext ).GlobalContext; InitializeBuiltinModules(); // TODO: Use reflection-only! _references = new List <KeyValuePair <Assembly, TopNamespaceTracker> >(); AddAssembly(LoadAssemblyInfo(typeof(string).Assembly)); AddAssembly(LoadAssemblyInfo(typeof(Debug).Assembly)); // cached for quick checks to see if we're a call to clr.AddReference SpecializeFunction("clr", "AddReference", (n, unit, args) => AddReference(n, null)); SpecializeFunction("clr", "AddReferenceByPartialName", (n, unit, args) => AddReference(n, ClrModule.LoadAssemblyByPartialName)); SpecializeFunction("clr", "AddReferenceByName", (n, unit, args) => AddReference(n, null)); SpecializeFunction("clr", "AddReferenceToFile", (n, unit, args) => AddReference(n, (s) => ClrModule.LoadAssemblyFromFile(_codeContext, s))); SpecializeFunction("clr", "AddReferenceToFileAndPath", (n, unit, args) => AddReference(n, (s) => ClrModule.LoadAssemblyFromFileWithPath(_codeContext, s))); try { SpecializeFunction("wpf", "LoadComponent", LoadComponent); } catch (KeyNotFoundException) { // IronPython.Wpf.dll isn't available... } SpecializeFunction("__builtin__", "range", (n, unit, args) => unit.DeclaringModule.GetOrMakeNodeVariable(n, (nn) => new RangeInfo(ClrModule.GetPythonType(typeof(List)), unit.ProjectState).SelfSet)); SpecializeFunction("__builtin__", "min", ReturnUnionOfInputs); SpecializeFunction("__builtin__", "max", ReturnUnionOfInputs); _builtinModule = (BuiltinModule)Modules["__builtin__"].Module; _propertyObj = GetBuiltin("property"); _classmethodObj = GetBuiltin("classmethod"); _staticmethodObj = GetBuiltin("staticmethod"); _typeObj = GetBuiltin("type"); _intType = GetBuiltin("int"); _stringType = (BuiltinClassInfo)GetBuiltin("str"); _objectSet = new HashSet <Namespace>(new[] { GetBuiltin("object") }); _setType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Set); _rangeFunc = GetBuiltin("range"); _frozensetType = GetBuiltin("frozenset"); _functionType = GetNamespaceFromObjects(TypeCache.Function); _generatorType = (BuiltinClassInfo)GetNamespaceFromObjects(DynamicHelpers.GetPythonTypeFromType(typeof(PythonGenerator))); _dictType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Dict); _boolType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Boolean); _noneInst = (ConstantInfo)GetNamespaceFromObjects(new object[] { null }); _listType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.List); _tupleType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.PythonTuple); _queue = new Queue <AnalysisUnit>(); _docProvider = CodeContext.LanguageContext.GetService <DocumentationProvider>(); }
public NumericInstanceInfo(BuiltinClassInfo klass) : base(klass) { }
public BaseIterableValue(BuiltinClassInfo seqType) : base(seqType) { }
internal ConstantInfo(BuiltinClassInfo klass, object value, PythonMemberType memberType) : base(klass) { _value = value; _memberType = memberType; _builtinInfo = klass.Instance; }
public IterableInfo(VariableDef[] indexTypes, BuiltinClassInfo seqType, Node node) : base(seqType) { _indexTypes = indexTypes; _node = node; }
public StarArgsSequenceInfo(VariableDef[] variableDef, BuiltinClassInfo builtinClassInfo, Node node, ProjectEntry entry) : base(variableDef, builtinClassInfo, node, entry) { }
private Dictionary<string, object> GenerateClassRef(BuiltinClassInfo ci) { return new Dictionary<string, object>() { { "type_name", GetTypeName(ci._type.DeclaringModule.Name, ci._type.Name) }, }; }
public override bool IsOfType(BuiltinClassInfo klass) { return _original.IsOfType(klass); }
public IterBoundBuiltinMethodInfo(VariableDef[] indexTypes, BuiltinClassInfo iterableClass) : base(new IterBuiltinMethodInfo(iterableClass.JType, iterableClass.ProjectState)) { _indexTypes = indexTypes; _iterClass = IteratorInfo.GetIteratorTypeFromType(iterableClass, iterableClass.ProjectState._evalUnit); }