private IAnalysisSet ListInsert(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 2) { AppendItem(node, unit, args[1]); } return unit.ProjectState._noneInst; }
public FromImportStatement(ModuleName root, NameExpression/*!*/[] names, NameExpression[] asNames, bool fromFuture, bool forceAbsolute) { _root = root; _names = names; _asNames = asNames; _fromFuture = fromFuture; _forceAbsolute = forceAbsolute; }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (_original == null) { return base.Call(node, unit, args, keywordArgNames); } return _original.Call(node, unit, args, keywordArgNames); }
public override ISet<Namespace> Call(Node node, AnalysisUnit unit, ISet<Namespace>[] args, NameExpression[] keywordArgNames) { _generator.Callers.AddDependency(unit); _generator.AddReturn(node, unit, base.Call(node, unit, args, keywordArgNames)); return _generator.SelfSet; }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var res = (DictionaryInfo)unit.Scope.GetOrMakeNodeValue( node, NodeValueKind.Dictionary, (node_) => new DictionaryInfo(unit.ProjectEntry, node) ); if (keywordArgNames.Length > 0) { for (int i = 0; i < keywordArgNames.Length; i++) { var curName = keywordArgNames[i].Name; var curArg = args[args.Length - keywordArgNames.Length + i]; if (curName == "**") { foreach (var value in curArg) { CopyFrom(args, res); } } else if (curName != "*") { res.AddTypes( node, unit, ProjectState.GetConstant(curName), curArg ); } } } else if (args.Length == 1) { foreach (var value in args[0]) { CopyFrom(args, res); } } return res; }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 1) { var res = unit.Scope.GetOrMakeNodeValue( node, (node_) => MakeFromIndexes(node_, unit.ProjectEntry) ) as SequenceInfo; List<IAnalysisSet> seqTypes = new List<IAnalysisSet>(); foreach (var type in args[0]) { SequenceInfo seqInfo = type as SequenceInfo; if (seqInfo != null) { for (int i = 0; i < seqInfo.IndexTypes.Length; i++) { if (seqTypes.Count == i) { seqTypes.Add(seqInfo.IndexTypes[i].Types); } else { seqTypes[i] = seqTypes[i].Union(seqInfo.IndexTypes[i].Types); } } } else { var defaultIndexType = type.GetIndex(node, unit, ProjectState.GetConstant(0)); if (seqTypes.Count == 0) { seqTypes.Add(defaultIndexType); } else { seqTypes[0] = seqTypes[0].Union(defaultIndexType); } } } res.AddTypes(unit, seqTypes.ToArray()); return res; } return base.Call(node, unit, args, keywordArgNames); }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var res = AnalysisSet.Empty; foreach (var member in _members) { res = res.Union(member.Call(node, unit, args, keywordArgNames)); } return res; }
private IAnalysisSet SequenceIter(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (_iterator == null) { var types = new [] { new VariableDef() }; types[0].AddTypes(unit, _indexTypes, false); _iterator = new IteratorInfo(types, IteratorInfo.GetIteratorTypeFromType(ClassInfo, unit), node); } return _iterator ?? AnalysisSet.Empty; }
internal void AddParameterReferences(AnalysisUnit caller, NameExpression[] names) { foreach (var name in names) { VariableDef param; if (name != null && TryGetVariable(name.Name, out param)) { param.AddReference(name, caller); } } }
private IAnalysisSet ListExtend(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 1) { foreach (var type in args[0]) { AppendItem(node, unit, type.GetEnumeratorTypes(node, unit)); } } return unit.ProjectState._noneInst; }
private IAnalysisSet ObjectSetAttr(Node node, Analysis.AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length >= 3) { foreach (var ii in args[0].OfType<InstanceInfo>()) { foreach (var key in args[1].GetConstantValueAsString()) { ii.SetMember(node, unit, key, args[2]); } } } return AnalysisSet.Empty; }
private IAnalysisSet IterableIter(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 0) { return unit.Scope.GetOrMakeNodeValue( node, NodeValueKind.Iterator, n => MakeIteratorInfo(n, unit) ); } return AnalysisSet.Empty; }
/// <summary> /// Performs a call operation propagating the argument types into any /// user defined functions or classes and returns the set of types which /// result from the call. /// </summary> public static IAnalysisSet Call(this IAnalysisSet self, Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var res = AnalysisSet.Empty; foreach (var ns in self) { var call = ns.Call(node, unit, args, keywordArgNames); Debug.Assert(call != null); res = res.Union(call); } return res; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { var realArgs = args; if (_inst != null) { realArgs = Utils.Concat(_inst.SelfSet, args); } if (node is CallExpression) { return _call((CallExpression)node, unit, realArgs, keywordArgNames) ?? NamespaceSet.Empty; } return NamespaceSet.Empty; }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var newArgs = _args.Take(_args.Length - _keywordArgNames.Length) .Concat(args.Take(args.Length - keywordArgNames.Length)) .Concat(_args.Skip(_args.Length - _keywordArgNames.Length)) .Concat(args.Skip(args.Length - keywordArgNames.Length)) .ToArray(); var newKwArgs = _keywordArgNames.Concat(keywordArgNames).ToArray(); return _function.Call(node, unit, newArgs, newKwArgs); }
public FunctionDefinition(NameExpression name, Parameter[] parameters, Statement body, DecoratorStatement decorators = null) { if (name == null) { _name = new NameExpression("<lambda>"); _isLambda = true; } else { _name = name; } _parameters = parameters; _body = body; _decorators = decorators; }
public override void PostWalk(NameExpression node) { if (IsInRange(node)) { if(_ast.LanguageVersion.Is2x()) { // In 2.7 True and False are constants, we made an exception to not show them Autos window. if(node.Name == "True" || node.Name == "False") { return; } } _expressions.Add(node, null); } }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var realArgs = args; if (_inst != null) { realArgs = Utils.Concat(_inst.SelfSet, args); } var res = _callable(node, unit, args, keywordArgNames); if (_mergeOriginalAnalysis && _original != null) { return res.Union(_original.Call(node, unit, args, keywordArgNames)); } return res; }
private IAnalysisSet IterableIter(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 0) { return unit.Scope.GetOrMakeNodeValue( node, n => new IteratorInfo( _indexTypes, IteratorInfo.GetIteratorTypeFromType(ClassInfo, unit), n ) ); } return AnalysisSet.Empty; }
private IAnalysisSet ObjectNew(Node node, Analysis.AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length >= 1) { var instance = AnalysisSet.Empty; foreach (var n in args[0]) { var bci = n as BuiltinClassInfo; var ci = n as ClassInfo; if (bci != null) { instance = instance.Union(bci.Instance); } else if (ci != null) { instance = instance.Union(ci.Instance); } } return instance; } return ProjectState.ClassInfos[BuiltinTypeId.Object].Instance; }
private IAnalysisSet DictionaryIterValues(Node node, Analysis.AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { _keysAndValues.AddDependency(unit); if (_valuesIter == null) { _valuesIter = new IteratorInfo( new[] { ValuesVariable }, unit.ProjectState.ClassInfos[BuiltinTypeId.DictValues], node ); } return _valuesIter; }
private IAnalysisSet DictionaryValues(Node node, Analysis.AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { _keysAndValues.AddDependency(unit); if (_valuesList == null) { _valuesList = new ListInfo( new[] { ValuesVariable }, unit.ProjectState.ClassInfos[BuiltinTypeId.List], node, unit.ProjectEntry ); } return _valuesList; }
private IAnalysisSet DictionaryPop(Node node, Analysis.AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { _keysAndValues.AddDependency(unit); return _keysAndValues.AllValueTypes; }
private IAnalysisSet DictionaryUpdate(Node node, Analysis.AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { if (args.Length >= 1) { foreach (var otherDict in args[0].OfType<DictionaryInfo>()) { if (!Object.ReferenceEquals(otherDict, this)) { _keysAndValues.CopyFrom(otherDict._keysAndValues); } } } // TODO: Process keyword args and add those values to our dictionary, plus a string key return AnalysisSet.Empty; }
public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { var res = base.Call(node, unit, args, keywordArgNames); if (Push()) { try { var callRes = GetTypeMember(node, unit, "__call__"); if (callRes.Any()) { res = res.Union(callRes.Call(node, unit, args, keywordArgNames)); } } finally { Pop(); } } return res; }
public FunctionDefinition(NameExpression name, Parameter[] parameters) : this(name, parameters, (Statement)null) { }
public override bool Walk(NameExpression node) { node.AddVariableReference(_globalScope, _bindRefs, Reference(node.Name)); return(true); }
/// <summary> /// Returns a new FromImport statement that is identical to this one but has /// removed the specified import statement. Otherwise preserves any attributes /// for the statement. /// /// New in 1.1. /// <param name="ast">The parent AST whose attributes should be updated for the new node.</param> /// <param name="index">The index in Names of the import to be removed.</param> /// </summary> public FromImportStatement RemoveImport(PythonAst ast, int index) { if (index < 0 || index >= Names.Count) { throw new ArgumentOutOfRangeException("index"); } if (ast == null) { throw new ArgumentNullException("ast"); } NameExpression[] names = new NameExpression[Names.Count - 1]; NameExpression[] asNames = AsNames == null ? null : new NameExpression[AsNames.Count - 1]; var asNameWhiteSpace = this.GetNamesWhiteSpace(ast); List <string> newAsNameWhiteSpace = new List <string>(); int importIndex = ImportIndex; int asIndex = 0; for (int i = 0, write = 0; i < Names.Count; i++) { bool includingCurrentName = i != index; // track the white space, this needs to be kept in sync w/ ToCodeString and how the // parser creates the white space. if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (write > 0) { if (includingCurrentName) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } else if (i > 0) { asIndex++; } } if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (includingCurrentName) { if (newAsNameWhiteSpace.Count == 0) { // no matter what we want the 1st entry to have the whitespace after the import keyword newAsNameWhiteSpace.Add(asNameWhiteSpace[0]); asIndex++; } else { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } } else { asIndex++; } } if (includingCurrentName) { names[write] = Names[i]; if (AsNames != null) { asNames[write] = AsNames[i]; } write++; } if (AsNames != null && AsNames[i] != null) { if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (i != index) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } if (AsNames[i].Name.Length != 0) { if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (i != index) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } } else { asIndex++; } } } if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { // trailing comma newAsNameWhiteSpace.Add(asNameWhiteSpace[asNameWhiteSpace.Length - 1]); } var res = new FromImportStatement(Root, names, asNames, IsFromFuture, ForceAbsolute, importIndex); ast.CopyAttributes(this, res); ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray()); return(res); }
private IAnalysisSet DictionaryGet(Node node, Analysis.AnalysisUnit unit, IAnalysisSet[] args, NameExpression[] keywordArgNames) { _keysAndValues.AddDependency(unit); if (args.Length == 1) { return _keysAndValues.GetValueType(args[0]); } else if (args.Length >= 2) { return _keysAndValues.GetValueType(args[0]).Union(args[1]); } return AnalysisSet.Empty; }
internal void AddNamedParameterReferences(AnalysisUnit caller, NameExpression[] names) { ((FunctionScope)Scope).AddParameterReferences(caller, names); }
public PartialFunctionInfo(ProjectEntry declProjEntry, IAnalysisSet function, IAnalysisSet[] args, NameExpression[] keywordArgNames) { _declProjEntry = declProjEntry; _function = function; _args = args; _keywordArgNames = keywordArgNames; }
public override bool Walk(NameExpression node) { _binder.DefineDeleted(node.Name); return(false); }
private static bool IsImplicitlyDefinedName(NameExpression nameExpr) { return nameExpr.Name == "__all__" || nameExpr.Name == "__file__" || nameExpr.Name == "__doc__" || nameExpr.Name == "__name__"; }
private PythonVariable _classVariable; // Variable for the classes __class__ cell var on 3.x public ClassDefinition(NameExpression /*!*/ name, Arg[] bases, Statement body) { _name = name; _bases = bases; _body = body; }