public void Visit(WithNode node) { if (node != null) { if (node.Body == null || node.Body.Count == 0) { DoesRequire = false; } else { node.Body.Accept(this); } } }
public void Visit(WithNode node) { // starts with 'with', so we don't care }
public void Visit(WithNode node) { DebugEx.Fail("shouldn't get here"); }
public override void Visit(WithNode node) { if (node != null) { // throw a warning discouraging the use of this statement if (ScopeStack.Peek().UseStrict) { // with-statements not allowed in strict code at all node.Context.HandleError(JSError.StrictModeNoWith, true); } else { // not strict, but still not recommended node.Context.HandleError(JSError.WithNotRecommended, false); } // hold onto the with-scope in case we need to do something with it BlockScope withScope = (node.Body == null ? null : node.Body.BlockScope); if (m_parser.Settings.StripDebugStatements && m_parser.Settings.IsModificationAllowed(TreeModifications.StripDebugStatements) && node.Body != null && node.Body.IsDebuggerStatement) { node.ReplaceChild(node.Body, null); } // recurse base.Visit(node); // we'd have to know what the object (obj) evaluates to before we // can figure out what to add to the scope -- not possible without actually // running the code. This could throw a whole bunch of 'undefined' errors. if (node.Body != null && node.Body.Count == 0) { node.ReplaceChild(node.Body, null); } // we got rid of the block -- tidy up the no-longer-needed scope if (node.Body == null && withScope != null) { // because the scope is empty, we now know it (it does nothing) withScope.IsKnownAtCompileTime = true; } } }
public void Visit(WithNode node) { ReportError(node); }
public void Visit(WithNode node) { // invalid! ignore IsValid = false; }