public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 0) { return unit.Scope.GetOrMakeNodeValue(node, n => new IteratorInfo(_indexTypes, _iterClass, n)); } return NamespaceSet.Empty; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 2) { _list.AppendItem(node, unit, args[1]); } return ProjectState._noneInst.SelfSet; }
public FromImportStatement(ModuleName root, NameExpression/*!*/[] names, NameExpression[] asNames, bool fromFuture, bool forceAbsolute) { _root = root; _names = names; _asNames = asNames; _fromFuture = fromFuture; _forceAbsolute = forceAbsolute; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 1) { _generator.AddSend(node, unit, args[0]); } _generator.Yields.AddDependency(unit); return _generator.Yields.Types; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 1) { foreach (var type in args[0]) { _list.AppendItem(node, unit, type.GetEnumeratorTypes(node, unit)); } } return ProjectState._noneInst.SelfSet; }
/// <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 INamespaceSet Call(this INamespaceSet self, Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { var res = NamespaceSet.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 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 INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length >= 1) { var instance = NamespaceSet.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._objectType.Instance; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { var realArgs = args; if (_inst != null) { realArgs = Utils.Concat(_inst.SelfSet, args); } var analyzed = _original.Call(node, unit, args, keywordArgNames); var res = _call((CallExpression)node, unit, realArgs, keywordArgNames); if (res == null) { return analyzed; } else if (analyzed.Count == 0) { return res; } else { return res.Union(analyzed); } }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length == 1) { var res = unit.Scope.GetOrMakeNodeValue( node, (node_) => MakeFromIndexes(node_) ) as SequenceInfo; List<INamespaceSet> seqTypes = new List<INamespaceSet>(); 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 RelativeModuleName(NameExpression[] names, int dotCount) : base(names) { _dotCount = dotCount; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { var res = NamespaceSet.Empty; foreach (var member in _members) { res = res.Union(member.Call(node, unit, args, keywordArgNames)); } return res; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { _myDict._keysAndValues.AddDependency(unit); if (_list == null) { var valuesVar = new VariableDef(); _myDict._keysAndValues.CopyValuesTo(valuesVar); _list = new ListInfo(new[] { valuesVar }, unit.ProjectState._listType, node); } return _list; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { _myDict._keysAndValues.AddDependency(unit); return _myDict._keysAndValues.AllValueTypes; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { if (args.Length >= 1) { foreach (var type in args[0]) { DictionaryInfo otherDict = type as DictionaryInfo; if (otherDict != null && !Object.ReferenceEquals(otherDict, _myDict)) { _myDict._keysAndValues.CopyFrom(otherDict._keysAndValues); } } } // TODO: Process keyword args and add those values to our dictionary, plus a string key return NamespaceSet.Empty; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { _myDict._keysAndValues.AddDependency(unit); if (_list == null) { _list = new IteratorInfo(new[] { _myDict.KeyValueTupleVariable }, unit.ProjectState._dictItemsType, node); } return _list; }
private void UpdateFromImport(JAst curAst, FromImportStatement fromImport) { NameExpression[] names = new NameExpression[fromImport.Names.Count + 1]; NameExpression[] asNames = fromImport.AsNames == null ? null : new NameExpression[fromImport.AsNames.Count + 1]; NameExpression newName = new NameExpression(_name); for (int i = 0; i < fromImport.Names.Count; i++) { names[i] = fromImport.Names[i]; } names[fromImport.Names.Count] = newName; if (asNames != null) { for (int i = 0; i < fromImport.AsNames.Count; i++) { asNames[i] = fromImport.AsNames[i]; } } var newImport = new FromImportStatement((ModuleName)fromImport.Root, names, asNames, fromImport.IsFromFuture, fromImport.ForceAbsolute); curAst.CopyAttributes(fromImport, newImport); var newCode = newImport.ToCodeString(curAst); var span = fromImport.GetSpan(curAst); using (var edit = _buffer.CreateEdit()) { edit.Delete(span.Start.Index, span.Length + fromImport.GetTrailingWhitespace(curAst).Length); edit.Insert(span.Start.Index, newCode); edit.Apply(); } }
private bool ProcessFutureStatements(int start, NameExpression/*!*/[] names, bool fromFuture) { if (!_fromFutureAllowed) { ReportSyntaxError(start, GetEnd(), "from __future__ imports must occur at the beginning of the file"); } if (names.Length == 1 && names[0].Name == "*") { ReportSyntaxError(start, GetEnd(), "future statement does not support import *"); } fromFuture = true; foreach (var name in names) { if (name.Name == "nested_scopes") { // v2.4 } else if (name.Name == "division") { _languageFeatures |= FutureOptions.TrueDivision; } else if (name.Name == "generators") { // v2.5: } else if (_langVersion >= JLanguageVersion.V71 && name.Name == "with_statement") { _languageFeatures |= FutureOptions.WithStatement; _tokenizer.WithStatement = true; } else if (_langVersion >= JLanguageVersion.V71 && name.Name == "absolute_import") { _languageFeatures |= FutureOptions.AbsoluteImports; // v2.6: } else if (_langVersion >= JLanguageVersion.V81 && name.Name == "print_function") { _languageFeatures |= FutureOptions.PrintFunction; _tokenizer.PrintFunction = true; } else if (_langVersion >= JLanguageVersion.V81 && name.Name == "unicode_literals") { _tokenizer.UnicodeLiterals = true; _languageFeatures |= FutureOptions.UnicodeLiterals; } else { string strName = name.Name; if (strName != "braces") { ReportSyntaxError(start, GetEnd(), "future feature is not defined: " + strName); } else { // match CJ error message ReportSyntaxError(start, GetEnd(), "not a chance"); } } } return fromFuture; }
/*!*/ private NameExpression MakeName(Name name) { var res = new NameExpression(name.RealName); AddVerbatimName(name, res); return res; }
//arglist: (argument ',')* (argument [',']| '*' expression [',' '**' expression] | '**' expression) //argument: [expression '='] expression # Really [keyword '='] expression private Arg[] FinishArgumentList(Arg first, List<string> commaWhiteSpace, out bool ateTerminator) { const TokenKind terminator = TokenKind.RightParenthesis; List<Arg> l = new List<Arg>(); if (first != null) { l.Add(first); } // Parse remaining arguments while (true) { if (MaybeEat(terminator)) { ateTerminator = true; break; } int start; Arg a; if (MaybeEat(TokenKind.Multiply)) { string starWhiteSpace = _tokenWhiteSpace; start = GetStart(); Expression t = ParseExpression(); var name = new NameExpression("*"); a = new Arg(name, t); if (_verbatim) { AddPreceedingWhiteSpace(name, starWhiteSpace); } } else if (MaybeEat(TokenKind.Power)) { string starStarWhiteSpace = _tokenWhiteSpace; start = GetStart(); Expression t = ParseExpression(); var name = new NameExpression("**"); a = new Arg(name, t); if (_verbatim) { AddPreceedingWhiteSpace(name, starStarWhiteSpace); } } else { Expression e = ParseExpression(); start = e.StartIndex; if (MaybeEat(TokenKind.Assign)) { a = FinishKeywordArgument(e); CheckUniqueArgument(l, a); } else { a = new Arg(e); } } a.SetLoc(start, GetEnd()); l.Add(a); if (MaybeEat(TokenKind.Comma)) { if (commaWhiteSpace != null) { commaWhiteSpace.Add(_tokenWhiteSpace); } } else { ateTerminator = Eat(terminator); break; } } return l.ToArray(); }
public virtual IEnumerable<AnalysisValue> Call(ISet<AnalysisValue>[] args, NameExpression[] keywordArgNames) { return EmptySet<AnalysisValue>.Instance; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { ISet<AnalysisValue>[] extArgs = new ISet<AnalysisValue>[args.Length]; for (int i = 0; i < args.Length; i++) { HashSet<AnalysisValue> set; extArgs[i] = set = new HashSet<AnalysisValue>(); foreach (var argValue in args[i]) { set.Add(argValue.AsExternal()); } } return ToNamespaceSet(_value.Call(extArgs, keywordArgNames)); }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { return _generator.GetEnumeratorTypes(node, unit); }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { var callArgs = ArgumentSet.FromArgs(FunctionDefinition, unit, args, keywordArgNames); if (_allCalls == null) { _allCalls = new Dictionary<CallChain, FunctionAnalysisUnit>(); } FunctionAnalysisUnit calledUnit; bool updateArguments = true; if (callArgs.Count == 0 || (ProjectState.Limits.UnifyCallsToNew && Name == "__new__")) { calledUnit = (FunctionAnalysisUnit)AnalysisUnit; } else { var chain = new CallChain(node, unit, unit.ProjectState.Limits.CallDepth); if (!_allCalls.TryGetValue(chain, out calledUnit)) { if (unit.ForEval) { // Call expressions that weren't analyzed get the union result // of all calls to this function. var res = NamespaceSet.Empty; foreach (var call in _allCalls.Values) { res = res.Union(call.ReturnValue.TypesNoCopy); } return res; } else { _allCalls[chain] = calledUnit = new FunctionAnalysisUnit((FunctionAnalysisUnit)AnalysisUnit, chain, callArgs); updateArguments = false; } } } if (updateArguments && calledUnit.UpdateParameters(callArgs)) { #if DEBUG // Checks whether these arguments can be added ad nauseum. if (calledUnit.UpdateParameters(callArgs) && calledUnit.UpdateParameters(callArgs) && calledUnit.UpdateParameters(callArgs)) { AnalysisLog.Add("BadArgs", calledUnit, callArgs); } #endif AnalysisLog.UpdateUnit(calledUnit); } calledUnit.ReturnValue.AddDependency(unit); return calledUnit.ReturnValue.Types; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { _myDict._keysAndValues.AddDependency(unit); if (args.Length == 1) { return _myDict._keysAndValues.GetValueType(args[0]); } else if (args.Length >= 2) { return _myDict._keysAndValues.GetValueType(args[0]).Union(args[1]); } return NamespaceSet.Empty; }
/// <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(JAst ast, int index) { if (index < 0 || index >= _names.Length) { throw new ArgumentOutOfRangeException("index"); } if (ast == null) { throw new ArgumentNullException("ast"); } NameExpression[] names = new NameExpression[_names.Length - 1]; NameExpression[] asNames = _asNames == null ? null : new NameExpression[_asNames.Length - 1]; var asNameWhiteSpace = this.GetNamesWhiteSpace(ast); List<string> newAsNameWhiteSpace = new List<string>(); int asIndex = 0; for (int i = 0, write = 0; i < _names.Length; 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); ast.CopyAttributes(this, res); ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray()); return res; }
public AssignmentScopeNode(JAst ast, AssignmentStatement assign, NameExpression name) { _assign = assign; _name = name; _ast = ast; }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { return _original.Call(node, unit, args, keywordArgNames); }
public override INamespaceSet Call(Node node, AnalysisUnit unit, INamespaceSet[] args, NameExpression[] keywordArgNames) { return _list.UnionType; }