Ejemplo n.º 1
0
        public void Visit(JsWithNode node)
        {
            if (node != null)
            {
                node.Index = NextOrderIndex;
                if (node.WithObject != null)
                {
                    node.WithObject.Accept(this);
                }

                if (node.Body != null)
                {
                    // create the with-scope and recurse the block.
                    // the block itself will push the scope onto the stack and pop it off, so we don't have to.
                    node.Body.BlockScope = new JsWithScope(CurrentLexicalScope, node.Body.Context, m_settings);

                    try
                    {
                        ++m_withDepth;
                        node.Body.Accept(this);
                    }
                    finally
                    {
                        --m_withDepth;
                    }
                }
            }
        }
 public void Visit(JsWithNode node)
 {
     // starts with 'with', so we don't care
 }
 public void Visit(JsWithNode node)
 {
     // starts with 'with', so we don't care
 }
 public void Visit(JsWithNode node)
 {
     // invalid! ignore
     IsValid = false;
 }
 public void Visit(JsWithNode node)
 {
     // invalid! ignore
     IsValid = false;
 }
Ejemplo n.º 6
0
 public void Visit(JsWithNode node)
 {
     // not applicable; terminate
 }
 public void Visit(JsWithNode node)
 {
     // not applicable; terminate
 }
 public void Visit(JsWithNode node)
 {
     Debug.Fail("shouldn't get here");
 }
        public void Visit(JsWithNode node)
        {
            if (node != null)
            {
                node.Index = NextOrderIndex;
                if (node.WithObject != null)
                {
                    node.WithObject.Accept(this);
                }

                if (node.Body != null)
                {
                    // create the with-scope and recurse the block.
                    // the block itself will push the scope onto the stack and pop it off, so we don't have to.
                    node.Body.BlockScope = new JsWithScope(CurrentLexicalScope, node.Body.Context, m_settings);

                    try
                    {
                        ++m_withDepth;
                        node.Body.Accept(this);
                    }
                    finally
                    {
                        --m_withDepth;
                    }
                }
            }
        }
Ejemplo n.º 10
0
 public void Visit(JsWithNode node)
 {
     Debug.Fail("shouldn't get here");
 }
Ejemplo n.º 11
0
        public void Visit(JsWithNode node)
        {
            if (node != null)
            {
                var symbol = StartSymbol(node);
                Output("with");
                SetContextOutputPosition(node.Context);
                if (m_settings.OutputMode == MinifierOutputMode.MultipleLines)
                {
                    OutputPossibleLineBreak(' ');
                }

                OutputPossibleLineBreak('(');
                m_startOfStatement = false;
                if (node.WithObject != null)
                {
                    node.WithObject.Accept(this);
                }
                OutputPossibleLineBreak(')');

                OutputBlock(node.Body);
                EndSymbol(symbol);
            }
        }
        public override void Visit(JsWithNode node)
        {
            if (node != null)
            {
                // throw a warning discouraging the use of this statement
                if (m_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
                JsBlockScope withScope = (node.Body == null ? null : node.Body.BlockScope);

                if (m_parser.Settings.StripDebugStatements
                     && m_parser.Settings.IsModificationAllowed(JsTreeModifications.StripDebugStatements)
                     && node.Body != null
                     && node.Body.IsDebuggerStatement)
                {
                    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.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;
                }
            }
        }