public override void EndNode(AstNode node) { base.EndNode(node); if (node is EntityDeclaration && node.Annotation<MemberReference>() != null) { MemberLocations[XmlDocKeyProvider.GetKey(node.Annotation<MemberReference>())] = node.StartLocation; } // code mappings var ranges = node.Annotation<List<ILRange>>(); if (symbolsStack.Count > 0 && ranges != null && ranges.Count > 0) { symbolsStack.Peek().SequencePoints.Add( new SequencePoint() { ILRanges = ILRange.OrderAndJoin(ranges).ToArray(), StartLocation = node.StartLocation, EndLocation = node.EndLocation }); } if (node.Annotation<MethodDebugSymbols>() != null) { var symbols = symbolsStack.Pop(); symbols.SequencePoints = symbols.SequencePoints.OrderBy(s => s.ILOffset).ToList(); symbols.StartLocation = node.StartLocation; symbols.EndLocation = node.EndLocation; DebugSymbols[XmlDocKeyProvider.GetKey(symbols.CecilMethod)] = symbols; } }
public virtual void VisitNullNode(AstNode nullNode) { // Should we call VisitChildren here? // We usually want to ignore null nodes. // Older NR versions (before VisitNullNode was introduced) didn't call VisitChildren() with null nodes; // so changing this might break VisitChildren() overrides that expect the node to be part of the AST. }
public virtual void AddLocals(IEnumerable<ParameterDeclaration> declarations, AstNode statement) { declarations.ToList().ForEach(item => { var name = this.Emitter.GetEntityName(item); var vName = this.AddLocal(item.Name, item.Type); if (item.ParameterModifier == ParameterModifier.Out || item.ParameterModifier == ParameterModifier.Ref) { this.Emitter.LocalsMap[item.Name] = name + ".v"; } else { this.Emitter.LocalsMap[item.Name] = name; } }); var visitor = new ReferenceArgumentVisitor(); statement.AcceptVisitor(visitor); foreach (var expr in visitor.DirectionExpression) { var rr = this.Emitter.Resolver.ResolveNode(expr, this.Emitter); if (rr is LocalResolveResult && expr is IdentifierExpression) { var ie = (IdentifierExpression)expr; this.Emitter.LocalsMap[ie.Identifier] = ie.Identifier + ".v"; } else { throw new EmitterException(expr, "Only local variables can be passed by reference"); } } }
private static Phrase FindPhrase(AstNode node) { var text = node.GetText(); if (node.Role == Roles.Comment) return Phrase.Comment; if (node.Role == Roles.Type) { var type = (node as PrimitiveType); if (type != null) return (type.Keyword != null) ? Phrase.Keyword : Phrase.Type; // some keywords can be type like "var" which our parser does not recognise return text.IsKeyword() ? Phrase.Keyword : Phrase.Type; } if (node is PrimitiveExpression) { if (text.IsString()) return Phrase.String; } if (node is CSharpTokenNode) { if (text.IsKeyword()) return Phrase.Keyword; } return Phrase.Unknwon; }
TextLocation GetEndOfPrev(AstNode node) { do { node = node.GetPrevNode(); } while (node.NodeType == NodeType.Whitespace); return node.EndLocation; }
public void Run(AstNode compilationUnit) { if (!context.Settings.QueryExpressions) return; DecompileQueries(compilationUnit); // After all queries were decompiled, detect degenerate queries (queries not property terminated with 'select' or 'group') // and fix them, either by adding a degenerate select, or by combining them with another query. foreach (QueryExpression query in compilationUnit.Descendants.OfType<QueryExpression>()) { QueryFromClause fromClause = (QueryFromClause)query.Clauses.First(); if (IsDegenerateQuery(query)) { // introduce select for degenerate query query.Clauses.Add(new QuerySelectClause { Expression = new IdentifierExpression(fromClause.Identifier) }); } // See if the data source of this query is a degenerate query, // and combine the queries if possible. QueryExpression innerQuery = fromClause.Expression as QueryExpression; while (IsDegenerateQuery(innerQuery)) { QueryFromClause innerFromClause = (QueryFromClause)innerQuery.Clauses.First(); if (fromClause.Identifier != innerFromClause.Identifier) break; // Replace the fromClause with all clauses from the inner query fromClause.Remove(); QueryClause insertionPos = null; foreach (var clause in innerQuery.Clauses) { query.Clauses.InsertAfter(insertionPos, insertionPos = clause.Detach()); } fromClause = innerFromClause; innerQuery = fromClause.Expression as QueryExpression; } } }
public override bool IsEquivalentTo(AstNode otherNode) { var otherRegExp = otherNode as RegExpLiteral; return otherRegExp != null && string.CompareOrdinal(Pattern, otherRegExp.Pattern) == 0 && string.CompareOrdinal(PatternSwitches, otherRegExp.PatternSwitches) == 0; }
public CodeObject Compile(AstNode syntaxNode, CodeProgram prog) { var syntax = (ScriptFunctionCall)syntaxNode; var parameters = syntax.Parameters.Select(expr => AstDomCompiler.Compile<CodeExpression>(expr, prog)).ToList(); var code = new CodeObjectFunctionCall(parameters); return code; }
/// <summary> /// Sets a value on a member of a basic type. /// </summary> /// <param name="ctx">The context of the runtime</param> /// <param name="varExp">The expression representing the index of the instance to set</param> /// <param name="valExp">The expression representing the value to set</param> /// <param name="node">The assignment ast node</param> public static void SetIndexValue(Context ctx, IAstVisitor visitor, AstNode node, Expr varExp, Expr valExp) { // 1. Get the value that is being assigned. var val = valExp.Evaluate(visitor) as LObject; // 2. Check the limit if string. ctx.Limits.CheckStringLength(node, val); // 3. Evaluate expression to get index info. var indexExp = varExp.Evaluate(visitor) as IndexAccess; if (indexExp == null) throw ComLib.Lang.Helpers.ExceptionHelper.BuildRunTimeException(node, "Value to assign is null"); // 4. Get the target of the index access and the name / number to set. var target = indexExp.Instance; var memberNameOrIndex = indexExp.MemberName; // Get methods associated with type. var methods = ctx.Methods.Get(target.Type); // Case 1: users[0] = 'kishore' if (target.Type == LTypes.Array) { var index = Convert.ToInt32(((LNumber)memberNameOrIndex).Value); methods.SetByNumericIndex(target, index, val); } // Case 2: users['total'] = 20 else if (target.Type == LTypes.Map) { var name = ((LString)memberNameOrIndex).Value; methods.SetByStringMember(target, name, val); } }
public ObjectLiteral(Context context, JSParser parser, ObjectLiteralField[] keys, AstNode[] values) : base(context, parser) { // the length of keys and values should be identical. // if either is null, or if the lengths don't match, we ignore both! if (keys == null || values == null || keys.Length != values.Length) { // allocate EMPTY arrays so we don't have to keep checking for nulls m_keys = new ObjectLiteralField[0]; m_values = new AstNode[0]; } else { // copy the arrays m_keys = keys; m_values = values; // make sure the parents are set properly foreach (AstNode astNode in keys) { astNode.Parent = this; } foreach (AstNode astNode in values) { astNode.Parent = this; } // because we don't ensure that the arrays are the same length, we'll need to // check for the minimum length every time we iterate over them } }
public override void StartNode(AstNode node) { currentList.Add(node); nodes.Push(currentList); currentList = new List<AstNode>(); base.StartNode(node); }
public void Run(AstNode node) { Run(node, null); // Declare all the variables at the end, after all the logic has run. // This is done so that definite assignment analysis can work on a single representation and doesn't have to be updated // when we change the AST. foreach (var v in variablesToDeclare) { if (v.ReplacedAssignment == null) { BlockStatement block = (BlockStatement)v.InsertionPoint.Parent; block.Statements.InsertBefore( v.InsertionPoint, new VariableDeclarationStatement((AstType)v.Type.Clone(), v.Name)); } } // First do all the insertions, then do all the replacements. This is necessary because a replacement might remove our reference point from the AST. foreach (var v in variablesToDeclare) { if (v.ReplacedAssignment != null) { // We clone the right expression so that it doesn't get removed from the old ExpressionStatement, // which might be still in use by the definite assignment graph. VariableDeclarationStatement varDecl = new VariableDeclarationStatement { Type = (AstType)v.Type.Clone(), Variables = { new VariableInitializer(v.Name, v.ReplacedAssignment.Right.Detach()).CopyAnnotationsFrom(v.ReplacedAssignment) } }; ExpressionStatement es = v.ReplacedAssignment.Parent as ExpressionStatement; if (es != null) { // Note: if this crashes with 'Cannot replace the root node', check whether two variables were assigned the same name es.ReplaceWith(varDecl.CopyAnnotationsFrom(es)); } else { v.ReplacedAssignment.ReplaceWith(varDecl); } } } variablesToDeclare = null; }
void Run(AstNode node, DefiniteAssignmentAnalysis daa) { BlockStatement block = node as BlockStatement; if (block != null) { var variables = block.Statements.TakeWhile(stmt => stmt is VariableDeclarationStatement) .Cast<VariableDeclarationStatement>().ToList(); if (variables.Count > 0) { // remove old variable declarations: foreach (VariableDeclarationStatement varDecl in variables) { Debug.Assert(varDecl.Variables.Single().Initializer.IsNull); varDecl.Remove(); } if (daa == null) { // If possible, reuse the DefiniteAssignmentAnalysis that was created for the parent block daa = new DefiniteAssignmentAnalysis(block, cancellationToken); } foreach (VariableDeclarationStatement varDecl in variables) { string variableName = varDecl.Variables.Single().Name; bool allowPassIntoLoops = varDecl.Variables.Single().Annotation<DelegateConstruction.CapturedVariableAnnotation>() == null; DeclareVariableInBlock(daa, block, varDecl.Type, variableName, allowPassIntoLoops); } } } for (AstNode child = node.FirstChild; child != null; child = child.NextSibling) { Run(child, daa); } }
string GetNodeTitle(AstNode node) { StringBuilder b = new StringBuilder(); b.Append(node.Role.ToString()); b.Append(": "); b.Append(node.GetType().Name); bool hasProperties = false; foreach (PropertyInfo p in node.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) { if (p.Name == "NodeType" || p.Name == "IsNull") continue; if (p.PropertyType == typeof(string) || p.PropertyType.IsEnum || p.PropertyType == typeof(bool)) { if (!hasProperties) { hasProperties = true; b.Append(" ("); } else { b.Append(", "); } b.Append(p.Name); b.Append(" = "); try { object val = p.GetValue(node, null); b.Append(val != null ? val.ToString() : "**null**"); } catch (TargetInvocationException ex) { b.Append("**" + ex.InnerException.GetType().Name + "**"); } } } if (hasProperties) b.Append(")"); return b.ToString(); }
protected override void EmitMethodParameters(IEnumerable<ParameterDeclaration> declarations, AstNode context, bool skipClose) { this.WriteOpenParentheses(); bool needComma = false; foreach (var p in declarations) { var name = this.Emitter.GetEntityName(p); if (needComma) { this.WriteComma(); } needComma = true; this.Write(name); this.WriteColon(); name = BridgeTypes.ToTypeScriptName(p.Type, this.Emitter); this.Write(name); } if (!skipClose) { this.WriteCloseParentheses(); } }
static IEnumerable<IType> GetAllValidTypesFromInvocation(CSharpAstResolver resolver, InvocationExpression invoke, AstNode parameter) { int index = GetArgumentIndex(invoke.Arguments, parameter); if (index < 0) yield break; var targetResult = resolver.Resolve(invoke.Target) as MethodGroupResolveResult; if (targetResult != null) { foreach (var method in targetResult.Methods) { if (index < method.Parameters.Count) { if (method.Parameters [index].IsParams) { var arrayType = method.Parameters [index].Type as ArrayType; if (arrayType != null) yield return arrayType.ElementType; } yield return method.Parameters [index].Type; } } foreach (var extMethods in targetResult.GetExtensionMethods ()) { foreach (var extMethod in extMethods) { if (index + 1 < extMethod.Parameters.Count) { if (extMethod.Parameters [index + 1].IsParams) { var arrayType = extMethod.Parameters [index + 1].Type as ArrayType; if (arrayType != null) yield return arrayType.ElementType; } yield return extMethod.Parameters [index + 1].Type; } } } } }
public ToolTipData (ICSharpCode.NRefactory.CSharp.SyntaxTree unit, ICSharpCode.NRefactory.Semantics.ResolveResult result, ICSharpCode.NRefactory.CSharp.AstNode node, CSharpAstResolver file) { this.Unit = unit; this.Result = result; this.Node = node; this.Resolver = file; }
public string MethodName; //either BindingInfo.Name, or name of the variable storing lambda expression #endregion Fields #region Constructors public Closure(Frame parentFrame, AstNode node, FunctionBindingInfo bindingInfo) { MethodName = bindingInfo.Name; ParentFrame = parentFrame; Node = node; BindingInfo = bindingInfo; }
public void Run(AstNode node) { if (node == null) throw new ArgumentNullException("node"); var initializer = node as VariableInitializer; if (initializer != null) { var newName = "_loc" + _ctr++; _locals[initializer.Name] = newName; initializer.ReplaceWith(new VariableInitializer(newName, initializer.Initializer)); } else { var identifier = node as IdentifierExpression; if (identifier != null) { string newName; if (_locals.TryGetValue(identifier.Identifier, out newName)) identifier.ReplaceWith(new IdentifierExpression(newName)); } } foreach (var c in node.Children) Run(c); }
public OverrideEqualsGetHashCodeMethodsDialog(InsertionContext context, ITextEditor editor, ITextAnchor endAnchor, ITextAnchor insertionPosition, ITypeDefinition selectedClass, IMethod selectedMethod, AstNode baseCallNode) : base(context, editor, insertionPosition) { if (selectedClass == null) throw new ArgumentNullException("selectedClass"); InitializeComponent(); this.selectedClass = selectedClass; this.insertionEndAnchor = endAnchor; this.selectedMethod = selectedMethod; this.baseCallNode = baseCallNode; addIEquatable.Content = string.Format(StringParser.Parse("${res:AddIns.SharpRefactoring.OverrideEqualsGetHashCodeMethods.AddInterface}"), "IEquatable<" + selectedClass.Name + ">"); string otherMethod = selectedMethod.Name == "Equals" ? "GetHashCode" : "Equals"; addOtherMethod.Content = StringParser.Parse("${res:AddIns.SharpRefactoring.OverrideEqualsGetHashCodeMethods.AddOtherMethod}", new StringTagPair("otherMethod", otherMethod)); addIEquatable.IsEnabled = !selectedClass.GetAllBaseTypes().Any( type => { if (!type.IsParameterized || (type.TypeParameterCount != 1)) return false; if (type.FullName != "System.IEquatable") return false; return type.TypeArguments.First().FullName == selectedClass.FullName; } ); }
public void Run(AstNode compilationUnit) { foreach (var en in compilationUnit.Descendants.OfType<EntityDeclaration>()) { var def = en.Annotation<IMemberDef>(); Debug.Assert(def != null); if (def == null) continue; if (def == type) { if (addPartialKeyword) { var tdecl = en as TypeDeclaration; Debug.Assert(tdecl != null); if (tdecl != null) { tdecl.Modifiers |= Modifiers.Partial; foreach (var iface in tdecl.BaseTypes) { var tdr = iface.Annotation<ITypeDefOrRef>(); if (tdr != null && ifacesToRemove.Contains(tdr)) iface.Remove(); } } } } else { if (showDefinitions) { if (!definitions.Contains(def)) en.Remove(); } else { if (definitions.Contains(def)) en.Remove(); } } } }
public AstNode GetParentFinallyBlock(AstNode node, bool stopOnLoops) { var insideTryFinally = false; var target = node.GetParent(n => { if (n is LambdaExpression || n is AnonymousMethodExpression || n is MethodDeclaration) { return true; } if (stopOnLoops && (n is WhileStatement || n is ForeachStatement || n is ForStatement || n is DoWhileStatement)) { return true; } if (n is TryCatchStatement && !((TryCatchStatement)n).FinallyBlock.IsNull) { insideTryFinally = true; return true; } return false; }); return insideTryFinally ? ((TryCatchStatement)target).FinallyBlock : null; }
public override void EndNode(AstNode node) { if (nodeStack.Pop() != node) throw new InvalidOperationException(); var startLocation = startLocations.Pop(); // code mappings var ranges = node.Annotation<List<ILRange>>(); if (symbolsStack.Count > 0 && ranges != null && ranges.Count > 0) { // Ignore the newline which was printed at the end of the statement TextLocation endLocation = (node is Statement) ? (lastEndOfLine ?? output.Location) : output.Location; symbolsStack.Peek().SequencePoints.Add( new SequencePoint() { ILRanges = ILRange.OrderAndJoin(ranges).ToArray(), StartLocation = startLocation, EndLocation = endLocation }); } if (node.Annotation<MethodDebugSymbols>() != null) { symbolsStack.Peek().EndLocation = output.Location; output.AddDebugSymbols(symbolsStack.Pop()); } }
public static bool RequiresParens(AstNode replaceNode, AstNode replaceWithNode) { if (!(replaceWithNode is BinaryOperatorExpression) && !(replaceWithNode is AssignmentExpression) && !(replaceWithNode is AsExpression) && !(replaceWithNode is IsExpression) && !(replaceWithNode is CastExpression) && !(replaceWithNode is LambdaExpression) && !(replaceWithNode is ConditionalExpression)) { return false; } var cond = replaceNode.Parent as ConditionalExpression; if (cond != null && cond.Condition == replaceNode) return true; var indexer = replaceNode.Parent as IndexerExpression; if (indexer != null && indexer.Target == replaceNode) return true; return replaceNode.Parent is BinaryOperatorExpression || replaceNode.Parent is UnaryOperatorExpression || replaceNode.Parent is AssignmentExpression || replaceNode.Parent is MemberReferenceExpression || replaceNode.Parent is AsExpression || replaceNode.Parent is IsExpression || replaceNode.Parent is CastExpression || replaceNode.Parent is LambdaExpression || replaceNode.Parent is PointerReferenceExpression; }
public void Run(AstNode compilationUnit) { foreach (InvocationExpression invocation in compilationUnit.Descendants.OfType<InvocationExpression>()) { MemberReferenceExpression mre = invocation.Target as MemberReferenceExpression; MethodReference methodReference = invocation.Annotation<MethodReference>(); if (mre != null && mre.Target is TypeReferenceExpression && methodReference != null && invocation.Arguments.Any()) { MethodDefinition d = methodReference.Resolve(); if (d != null) { foreach (var ca in d.CustomAttributes) { if (ca.AttributeType.Name == "ExtensionAttribute" && ca.AttributeType.Namespace == "System.Runtime.CompilerServices") { var firstArgument = invocation.Arguments.First(); if (firstArgument is NullReferenceExpression) firstArgument = firstArgument.ReplaceWith(expr => expr.CastTo(AstBuilder.ConvertType(d.Parameters.First().ParameterType))); else mre.Target = firstArgument.Detach(); if (invocation.Arguments.Any()) { // HACK: removing type arguments should be done indepently from whether a method is an extension method, // just by testing whether the arguments can be inferred mre.TypeArguments.Clear(); } break; } } } } } }
public override void Init(ParsingContext context, ParseTreeNode treeNode) { base.Init(context, treeNode); Test = AddChild("Test", treeNode.ChildNodes[0]); IfTrue = AddChild("IfTrue", treeNode.ChildNodes[1]); if (treeNode.ChildNodes.Count > 2) IfFalse = AddChild("IfFalse", treeNode.ChildNodes[2]); }
public override void StartNode(AstNode node) { if (parameterIndex == highlightedParameterIndex && node is ParameterDeclaration) { parameterStartOffset = b.Length; } base.StartNode(node); }
public override void Init(ParsingContext context, ParseTreeNode treeNode) { base.Init(context, treeNode); TargetRef = AddChild("Target", treeNode.ChildNodes[0]); _targetName = treeNode.ChildNodes[0].FindTokenAndGetText(); Arguments = AddChild("Args", treeNode.ChildNodes[1]); AsString = "Call " + _targetName; }
private void InitImpl(AstContext context, ParseTreeNode parseNode, ParseTreeNode parametersNode, ParseTreeNode bodyNode) { base.Init(context, parseNode); Parameters = AddChild("Parameters", parametersNode); Body = AddChild("Body", bodyNode); AsString = "Lambda[" + Parameters.ChildNodes.Count + "]"; Body.SetIsTail(); //this will be propagated to the last statement }
IEnumerable<CodeAction> GetActionsForAddNamespaceUsing(RefactoringContext context, AstNode node) { var nrr = context.Resolve(node) as NamespaceResolveResult; if (nrr == null) return EmptyList<CodeAction>.Instance; var trr = context.Resolve(node.Parent) as TypeResolveResult; if (trr == null) return EmptyList<CodeAction>.Instance; ITypeDefinition typeDef = trr.Type.GetDefinition(); if (typeDef == null) return EmptyList<CodeAction>.Instance; IList<IType> typeArguments; ParameterizedType parameterizedType = trr.Type as ParameterizedType; if (parameterizedType != null) typeArguments = parameterizedType.TypeArguments; else typeArguments = EmptyList<IType>.Instance; var resolver = context.GetResolverStateBefore(node.Parent); if (resolver.ResolveSimpleName(typeDef.Name, typeArguments) is UnknownIdentifierResolveResult) { // It's possible to remove the explicit namespace usage and introduce a using instead return new[] { NewUsingAction(context, node, typeDef.Namespace) }; } return EmptyList<CodeAction>.Instance; }
/// <summary> /// 各种表达式 /// </summary> /// <param name="expr"></param> string ParseObjectCreateExpression(AstNode expr) { string newtype = ""; foreach (var v in expr.Children) { if (v is Comment) { Append(v.ToString().Replace("\r\n", "")); } else if (v is PrimitiveType) { newtype = Tools.getPrimitiveTypeName(v.ToString()); Append(newtype); } else if (v is MemberType) { newtype = getMemberTypeName(v.ToString()); Append(newtype); } else if (v is SimpleType) { newtype = getSimpleTypeName((v as SimpleType).Identifier); Append(newtype); } else if (v is CSharpTokenNode) { if (v.ToString() == "(")//param begin; { Append("("); } else if (v.ToString() == ")")//paramend; { Append(")"); } else if (v.ToString() == "new") { Append("new "); } else { Append(v.ToString()); } } else if (v is NewLineNode) { AppendLine(); } else if (v is BlockStatement) { ParseBlockStatement(v, null); } else if (v is IdentifierExpression) {//add param ParseIdentifierExpression(v as IdentifierExpression, null); } else { logger.LogError("not support ParseObjectCreateExpression element:" + v.GetType().Name + "|" + v.NodeType + "|" + v.StartLocation.Line); } } return newtype; }
public override object VisitBlockStatement(BlockStatement blockStatement, object data) { base.VisitBlockStatement(blockStatement, data); foreach (ExpressionStatement stmt in blockStatement.Statements.OfType <ExpressionStatement>().ToArray()) { Match displayClassAssignmentMatch = displayClassAssignmentPattern.Match(stmt); if (displayClassAssignmentMatch == null) { continue; } ILVariable variable = displayClassAssignmentMatch.Get("variable").Single().Annotation <ILVariable>(); if (variable == null) { continue; } TypeDefinition type = variable.Type.ResolveWithinSameModule(); if (!IsPotentialClosure(context, type)) { continue; } if (displayClassAssignmentMatch.Get("type").Single().Annotation <TypeReference>().ResolveWithinSameModule() != type) { continue; } // Looks like we found a display class creation. Now let's verify that the variable is used only for field accesses: bool ok = true; foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>()) { if (identExpr.Identifier == variable.Name && identExpr != displayClassAssignmentMatch.Get("variable").Single()) { if (!(identExpr.Parent is MemberReferenceExpression && identExpr.Parent.Annotation <FieldReference>() != null)) { ok = false; } } } if (!ok) { continue; } Dictionary <FieldReference, AstNode> dict = new Dictionary <FieldReference, AstNode>(); // Delete the variable declaration statement: AstNode cur = stmt.NextSibling; stmt.Remove(); if (blockStatement.Parent.NodeType == NodeType.Member || blockStatement.Parent is Accessor) { // Delete any following statements as long as they assign parameters to the display class // Do parameter handling only for closures created in the top scope (direct child of method/accessor) List <ILVariable> parameterOccurrances = blockStatement.Descendants.OfType <IdentifierExpression>() .Select(n => n.Annotation <ILVariable>()).Where(p => p != null && p.IsParameter).ToList(); AstNode next; for (; cur != null; cur = next) { next = cur.NextSibling; // Test for the pattern: // "variableName.MemberName = right;" ExpressionStatement closureFieldAssignmentPattern = new ExpressionStatement( new AssignmentExpression( new NamedNode("left", new MemberReferenceExpression { Target = new IdentifierExpression(variable.Name) }), new AnyNode("right") ) ); Match m = closureFieldAssignmentPattern.Match(cur); if (m != null) { AstNode right = m.Get("right").Single(); bool isParameter = false; if (right is ThisReferenceExpression) { isParameter = true; } else if (right is IdentifierExpression) { // handle parameters only if the whole method contains no other occurrance except for 'right' ILVariable param = right.Annotation <ILVariable>(); isParameter = param.IsParameter && parameterOccurrances.Count(c => c == param) == 1; } if (isParameter) { dict[m.Get <MemberReferenceExpression>("left").Single().Annotation <FieldReference>().ResolveWithinSameModule()] = right; cur.Remove(); } else { break; } } else { break; } } } // Now create variables for all fields of the display class (except for those that we already handled as parameters) List <Tuple <AstType, string> > variablesToDeclare = new List <Tuple <AstType, string> >(); foreach (FieldDefinition field in type.Fields) { if (dict.ContainsKey(field)) { continue; } variablesToDeclare.Add(Tuple.Create(AstBuilder.ConvertType(field.FieldType, field), field.Name)); dict[field] = new IdentifierExpression(field.Name); } // Now figure out where the closure was accessed and use the simpler replacement expression there: foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>()) { if (identExpr.Identifier == variable.Name) { MemberReferenceExpression mre = (MemberReferenceExpression)identExpr.Parent; AstNode replacement; if (dict.TryGetValue(mre.Annotation <FieldReference>().ResolveWithinSameModule(), out replacement)) { mre.ReplaceWith(replacement.Clone()); } } } // Now insert the variable declarations (we can do this after the replacements only so that the scope detection works): Statement insertionPoint = blockStatement.Statements.FirstOrDefault(); foreach (var tuple in variablesToDeclare) { var newVarDecl = new VariableDeclarationStatement(tuple.Item1, tuple.Item2); newVarDecl.Variables.Single().AddAnnotation(new CapturedVariableAnnotation()); blockStatement.Statements.InsertBefore(insertionPoint, newVarDecl); } } return(null); }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { return(child.DoMatch(other, match)); }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { return(other == null || other.IsNull); }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { VariableInitializer o = other as VariableInitializer; return(o != null && MatchString(this.Name, o.Name) && this.Initializer.DoMatch(o.Initializer, match)); }
string ParseInvocationExpression(AstNode expr)//处理函数调用 { string returntype = null; ExpressOption option = new ExpressOption(); option.paramType = null; option.memberCall = true; StringBuilder old = null; foreach (var v in expr.Children) { if (v is IdentifierExpression) { if (option.paramType == null) { Append(""); continue;//delaycall } else { option.paramType.Add(ParseIdentifierExpression(v as IdentifierExpression, null)); } } else if (v is MemberReferenceExpression) { if (option.paramType == null) { Append(""); continue;//delaycall } else { option.paramType.Add(ParseMemberReferenceExpression(v as MemberReferenceExpression, null)); } } if (v is CSharpTokenNode) { if (v.ToString() == "(") {//将参数处理到自定义的地方 old = this.builder; this.builder = new StringBuilder(); option.paramType = new List<string>(); } Append(v.ToString()); if (v.ToString() == ")") { string callbody = this.builder.ToString(); this.builder = old; //此时再去处理 foreach (var vv in expr.Children) { if (vv is IdentifierExpression) { ParseIdentifierExpression(vv as IdentifierExpression, option); break; } else if (vv is MemberReferenceExpression) { ParseMemberReferenceExpression(vv as MemberReferenceExpression, option); break; } } Append(callbody); } } else if (v is PrimitiveExpression) { option.paramType.Add(ParsePrimitiveExpression(v)); } else { logger.LogError("not support ParseInvocationExpression element:" + v.GetType().Name + "|" + expr.NodeType + "|" + expr.StartLocation.Line); } } return returntype; }
string ParseThisReferenceExpression(AstNode expr)//this { Append("this"); return getCurClassName(); }
public abstract void EndNode(AstNode node);
public override void EndNode(AstNode node) { decoratedWriter.EndNode(node); }
public void Run(AstNode compilationUnit) { // First determine all the namespaces that need to be imported: compilationUnit.AcceptVisitor(new FindRequiredImports(this), null); importedNamespaces.Add("System"); // always import System, even when not necessary if (context.Settings.UsingDeclarations) { // Now add using declarations for those namespaces: foreach (string ns in importedNamespaces.OrderByDescending(n => n)) { // we go backwards (OrderByDescending) through the list of namespaces because we insert them backwards // (always inserting at the start of the list) string[] parts = ns.Split('.'); AstType nsType = new SimpleType(parts[0]).WithAnnotation(TextTokenType.NamespacePart); for (int i = 1; i < parts.Length; i++) { nsType = new MemberType { Target = nsType, MemberNameToken = Identifier.Create(parts[i]).WithAnnotation(TextTokenType.NamespacePart) }.WithAnnotation(TextTokenType.NamespacePart); } compilationUnit.InsertChildAfter(null, new UsingDeclaration { Import = nsType }, SyntaxTree.MemberRole); } } if (!context.Settings.FullyQualifyAmbiguousTypeNames) { return; } if (context.CurrentModule != null) { FindAmbiguousTypeNames(context.CurrentModule.Types, internalsVisible: true); if (context.CurrentModule is ModuleDefMD) { var asmDict = new Dictionary <AssemblyDef, List <AssemblyDef> >(AssemblyEqualityComparer.Instance); foreach (var r in ((ModuleDefMD)context.CurrentModule).GetAssemblyRefs()) { AssemblyDef d = context.CurrentModule.Context.AssemblyResolver.Resolve(r, context.CurrentModule); if (d == null) { continue; } List <AssemblyDef> list; if (!asmDict.TryGetValue(d, out list)) { asmDict.Add(d, list = new List <AssemblyDef>()); } list.Add(d); } foreach (var list in asmDict.Values) { FindAmbiguousTypeNames(GetTypes(list), internalsVisible: false); } } } // verify that the SimpleTypes refer to the correct type (no ambiguities) compilationUnit.AcceptVisitor(new FullyQualifyAmbiguousTypeNamesVisitor(this), null); }
/// <summary> /// Gets whether the expression acts like a parenthesized expression, /// i.e. whether information about the expected type (for lambda type inference) flows /// into the inner expression. /// </summary> /// <returns>Returns true for ParenthesizedExpression, CheckedExpression or UncheckedExpression; false otherwise.</returns> public static bool ActsAsParenthesizedExpression(AstNode expression) { return(expression is ParenthesizedExpression || expression is CheckedExpression || expression is UncheckedExpression); }
public abstract void StartNode(AstNode node);
public static void AddAllRecursiveILRangesTo(this IEnumerable <AstNode> nodes, AstNode target) { if (nodes == null) { return; } var ilRanges = nodes.GetAllRecursiveILRanges(); if (ilRanges.Count > 0) { target.AddAnnotation(ilRanges); } }
public override void StartNode(AstNode node) { decoratedWriter.StartNode(node); }
public IParameterDataProvider CreateConstructorProvider(int startOffset, ICSharpCode.NRefactory.TypeSystem.IType type, AstNode skipNode) { Assert.IsTrue(type.Kind != TypeKind.Unknown); return(new Provider() { Data = type.GetConstructors(m => m.Accessibility == Accessibility.Public) }); }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { ParenthesizedExpression o = other as ParenthesizedExpression; return(o != null && this.Expression.DoMatch(o.Expression, match)); }
public static bool TypeChangeResolvesCorrectly(BaseRefactoringContext ctx, ParameterDeclaration parameter, AstNode rootNode, IType type) { var resolver = ctx.GetResolverStateBefore(rootNode); resolver = resolver.AddVariable(new DefaultParameter(type, parameter.Name)); var astResolver = new CSharpAstResolver(resolver, rootNode, ctx.UnresolvedFile); var validator = new TypeChangeValidationNavigator(); astResolver.ApplyNavigator(validator, ctx.CancellationToken); return(!validator.FoundErrors); }
public IParameterDataProvider CreateIndexerParameterDataProvider(int startOffset, IType type, AstNode resolvedNode) { Assert.IsTrue(type.Kind != TypeKind.Unknown); if (type.Kind == TypeKind.Array) { return(new ArrayProvider()); } return(new IndexerProvider() { Data = type.GetProperties(p => p.IsIndexer) }); }
public void Run(AstNode node) { node.AcceptVisitor(this, null); }
public void Resolved(AstNode node, ResolveResult result) { // bool errors = result.IsError; FoundErrors |= result.IsError; }
public MapItemExpression(AstNode parent, Expression left, Expression right) : base(parent) { Left = left; Right = right; }
protected virtual void EmitMethodParameters(IEnumerable <ParameterDeclaration> declarations, AstNode context) { this.WriteOpenParentheses(); bool needComma = false; foreach (var p in declarations) { var name = this.Emitter.GetParameterName(p); if (needComma) { this.WriteComma(); } needComma = true; this.Write(name); this.WriteColon(); name = BridgeTypes.ToTypeScriptName(p.Type, this.Emitter); this.Write(name); var resolveResult = this.Emitter.Resolver.ResolveNode(p.Type, this.Emitter); if (resolveResult != null && (resolveResult.Type.IsReferenceType.HasValue && resolveResult.Type.IsReferenceType.Value || resolveResult.Type.IsKnownType(KnownTypeCode.NullableOfT))) { this.Write(" | null"); } } this.WriteCloseParentheses(); }
public Scope(AstNode node, Scope parent) { Node = node; Parent = parent; Level = (short)(parent == null ? 0 : parent.Level + 1); }
internal BraceCollectionExpression( AstNode parent, BraceCollectionType type = BraceCollectionType.Unknown ) : base(parent) { Expressions = new NodeList <Expression>(this); Type = type; MarkStartAndEat(OpenBrace); if (!Peek.Is(CloseBrace)) { var comprehension = false; while (true) { Expression item = ParseInfixExpr(this); if (comprehension) { Unit.Blame( BlameType.CollectionInitializerCannotContainItemsAfterComprehension, item ); } // map item (expr ':' expr) if (MaybeEat(Colon)) { if (Type == BraceCollectionType.Set) { Unit.ReportError("Single expression expected", Token); } Type = BraceCollectionType.Map; item = new MapItemExpression( this, item, ParseInfixExpr(this) ); } // set item (expr) else { if (Type == BraceCollectionType.Map) { Unit.ReportError("'Key : Value' expression expected", Token); } Type = BraceCollectionType.Set; } if (Peek.Is(KeywordFor)) { item = new ForComprehension(this, item); comprehension = true; } Expressions.Add(item); if (Peek.Is(CloseBrace)) { break; } Eat(Comma); } } MarkEndAndEat(CloseBrace); if (Expressions.Count == 0) { Unit.Blame(BlameType.EmptyCollectionLiteralNotSupported, this); } }
public TableIndexingNode(VariableNode variable, AstNode keyExpression) { Variable = variable; KeyExpression = keyExpression; }
void IResolveVisitorNavigator.Resolved(AstNode node, ResolveResult result) { }
public override void VisitNullNode(AstNode nullNode) { new NullReferenceBlock(this, nullNode).Emit(); }
protected internal override bool DoMatch(AstNode other, Match match) { CommentStatement o = other as CommentStatement; return(o != null && MatchString(comment, o.comment)); }
public LambdaBlock(IEmitter emitter, IEnumerable <ParameterDeclaration> parameters, AstNode body, AstNode context, bool isAsync) : base(emitter, context) { this.Emitter = emitter; this.Parameters = parameters; this.Body = body; this.Context = context; this.IsAsync = isAsync; }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { CastExpression o = other as CastExpression; return(o != null && this.Type.DoMatch(o.Type, match) && this.Expression.DoMatch(o.Expression, match)); }