Ruby » Ruby master

assert_equal '1',       %q( C = 1   # [yarv-dev:800]

                            begin module C; end; rescue TypeError; 1 end )

assert_equal '1',       %q( class A; end;  A::C = 1;  A::C )

assert_equal '1',       %q( A = 7;  begin A::C = 7; rescue TypeError; 1 end )

assert_equal '1',       %q( begin 7::C = 7; rescue TypeError; 1 end )

	debugi("compile_colon2 - colon", node->nd_vid);

	ADD_INSN1(body, nd_line(node), getconstant, ID2SYM(node->nd_vid));

	break;

	ADD_INSN(body, nd_line(node), pop);

	ADD_INSN1(body, nd_line(node), putobject, rb_cObject);

	ADD_INSN1(body, nd_line(node), getconstant, ID2SYM(node->nd_mid));

static VALUE

compile_cpath(LINK_ANCHOR *ret, rb_iseq_t *iseq, NODE *cpath)

{

	/* toplevel class ::Foo */

	ADD_INSN1(ret, nd_line(cpath), putobject, rb_cObject);

	return Qfalse;

		      ID2SYM(node->nd_mid), needstr);

	}

	return 1;

	ADD_INSN1(ret, nd_line(node), putobject, rb_cObject);

	ADD_INSN3(ret, nd_line(node), defined,

		  INT2FIX(DEFINED_CONST), ID2SYM(node->nd_mid), needstr);

	ID mid;

	switch (nd_type(node->nd_head)) {

	    ADD_INSN1(ret, line, putobject, rb_cObject);

	    break;

	  case NODE_COLON2:

	}

	break;

      }

	LABEL *lend = NEW_LABEL(line);

	int ic_index = iseq->is_size++;

	/* add cache insn */

	if (iseq->compile_data->option->inline_const_cache) {

		COUNT_NODE(NODE_MODULE);

		COUNT_NODE(NODE_SCLASS);

		COUNT_NODE(NODE_COLON2);

		COUNT_NODE(NODE_CREF);

		COUNT_NODE(NODE_DOT2);

		COUNT_NODE(NODE_DOT3);

    {tCHAR,		&ripper_id_CHAR},

    {tCMP,		&ripper_id_op},

    {tCOLON2,		&ripper_id_op},

    {tCONSTANT,		&ripper_id_const},

    {tCVAR,		&ripper_id_cvar},

    {tDOT2,		&ripper_id_op},

       |op, io|

      if @lex_state == EXPR_BEG or @lex_state == EXPR_ARG && @space_seen

        @lex_state = EXPR_BEG

      else

        @lex_state = EXPR_DOT

        Token(TkCOLON2)

    [:TkLSHFT,      TkOp,   "<<"],

    [:TkRSHFT,      TkOp,   ">>"],

    [:TkCOLON2,     TkOp],

    [:TkASSOC,      TkOp,   "=>"],

    [:TkQUESTION,   TkOp,   "?"],	 #?

    [:TkCOLON,      TkOp,   ":"],        #:

    # class ::A -> A is in the top level

    case name_t

      name_t = get_tk

      container = @top_level

      given_name << '::'

    skip_tkspace false

    tk = get_tk

      res += tk.name

      tk = get_tk

    end

          unget_tk tk

          break

        end

        rhs_name << '::'

      when nil then

        break

      #      p @lex_state.id2name, @space_seen

      if @lex_state == :EXPR_BEG or @lex_state == :EXPR_ARG && @space_seen

        @lex_state = :EXPR_BEG

      else

        @lex_state = :EXPR_DOT

        Token(TkCOLON2)

    [:TkLSHFT,      TkOp,   "<<"],

    [:TkRSHFT,      TkOp,   ">>"],

    [:TkCOLON2,     TkOp,   '::'],

    #[:OPASGN,       TkOp],               # +=, -=  etc. #

    [:TkASSOC,      TkOp,   "=>"],

    [:TkQUESTION,   TkOp,   "?"], #?

	F_NODE(nd_head, "receiver");

	break;

	ANN("top-level constant reference");

	ANN("format: ::[nd_mid]");

	ANN("example: ::Object");

      case NODE_IASGN:

      case NODE_IASGN2:

      case NODE_CVASGN:

      case NODE_OPT_N:

      case NODE_EVSTR:

      case NODE_UNDEF:

#define NODE_SCLASS      NODE_SCLASS

    NODE_COLON2,

#define NODE_COLON2      NODE_COLON2

    NODE_CREF,

#define NODE_CREF        NODE_CREF

    NODE_DOT2,

#define NEW_SCLASS(r,b) NEW_NODE(NODE_SCLASS,r,NEW_SCOPE(0,b),0)

#define NEW_MODULE(n,b) NEW_NODE(NODE_MODULE,n,NEW_SCOPE(0,b),0)

#define NEW_COLON2(c,i) NEW_NODE(NODE_COLON2,c,i,0)

#define NEW_CREF(a) NEW_NODE(NODE_CREF,a,0,0)

#define NEW_DOT2(b,e) NEW_NODE(NODE_DOT2,b,e,0)

#define NEW_DOT3(b,e) NEW_NODE(NODE_DOT3,b,e,0)

%token tLSHFT		RUBY_TOKEN(LSHFT)  "<<"

%token tRSHFT		RUBY_TOKEN(RSHFT)  ">>"

%token tCOLON2		"::"

%token <id> tOP_ASGN	/* +=, -=  etc. */

%token tASSOC		"=>"

%token tLPAREN		"("

			}

		    %*/

		    }

		    {

		    /*%%%*/

			if (in_def || in_single)

			    yyerror("dynamic constant assignment");

		    /*%

			$$ = dispatch1(top_const_field, $2);

			if (in_def || in_single) {

			}

		    %*/

		    }

		    {

		    /*%%%*/

			if (in_def || in_single)

			    yyerror("dynamic constant assignment");

		    /*%

			$$ = dispatch1(top_const_field, $2);

			if (in_def || in_single) {

		| tCONSTANT

		;

		    {

		    /*%%%*/

		    /*%

			$$ = dispatch1(top_const_ref, $2);

		    %*/

			$$ = dispatch3(opassign, $$, $4, $5);

		    %*/

		    }

		    {

		    /*%%%*/

			$$ = new_const_op_assign($$, $3, $4);

		    /*%

			$$ = dispatch1(top_const_field, $2);

			$$ = dispatch2(const_path_ref, $1, $3);

		    %*/

		    }

		    {

		    /*%%%*/

		    /*%

			$$ = dispatch1(top_const_ref, $2);

		    %*/

	if (c == ':') {

	    if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {

		lex_state = EXPR_BEG;

	    }

	    lex_state = EXPR_DOT;

	    return tCOLON2;

	useless = "a literal";

	break;

      case NODE_COLON2:

	useless = "::";

	break;

      case NODE_DOT2:

token_op_ids = %w[

  tDOT2 tDOT3 tUPLUS tUMINUS tPOW tDSTAR tCMP tLSHFT tRSHFT

  tLEQ tGEQ tEQ tEQQ tNEQ tMATCH tNMATCH tAREF tASET

]

defs = File.join(File.dirname(File.dirname(erb.filename)), "defs/id.def")

    assert_empty foo.comment

  end

    code = <<-CODE

class A

  class ::B

    assert_equal %w[A B], @store.all_classes.map { |c| c.full_name }.sort

  end

    code = <<-CODE

class A::B

  class ::A