Mercurial > hg > graal-jvmci-8
annotate graal/com.oracle.truffle.ruby.nodes/src/com/oracle/truffle/ruby/nodes/core/ModuleNodes.java @ 13706:232eb6708943
Ruby: required fixes for moving FrameDescriptor to the RootNode.
| author | Christian Humer <christian.humer@gmail.com> |
|---|---|
| date | Mon, 20 Jan 2014 13:44:54 +0100 |
| parents | 0fbee3eb71f0 |
| children |
| rev | line source |
|---|---|
| 13514 | 1 /* |
| 2 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved. This | |
| 3 * code is released under a tri EPL/GPL/LGPL license. You can use it, | |
| 4 * redistribute it and/or modify it under the terms of the: | |
| 5 * | |
| 6 * Eclipse Public License version 1.0 | |
| 7 * GNU General Public License version 2 | |
| 8 * GNU Lesser General Public License version 2.1 | |
| 9 */ | |
| 10 package com.oracle.truffle.ruby.nodes.core; | |
| 11 | |
| 12 import com.oracle.truffle.api.*; | |
| 13 import com.oracle.truffle.api.dsl.*; | |
| 14 import com.oracle.truffle.api.frame.*; | |
| 15 import com.oracle.truffle.api.nodes.*; | |
| 16 import com.oracle.truffle.ruby.nodes.*; | |
| 17 import com.oracle.truffle.ruby.nodes.control.*; | |
| 18 import com.oracle.truffle.ruby.nodes.methods.arguments.*; | |
| 19 import com.oracle.truffle.ruby.nodes.objects.*; | |
| 20 import com.oracle.truffle.ruby.nodes.objects.instancevariables.*; | |
| 21 import com.oracle.truffle.ruby.runtime.*; | |
| 22 import com.oracle.truffle.ruby.runtime.RubyParser.*; | |
| 23 import com.oracle.truffle.ruby.runtime.core.*; | |
| 24 import com.oracle.truffle.ruby.runtime.core.array.*; | |
| 25 import com.oracle.truffle.ruby.runtime.methods.*; | |
| 26 | |
| 27 @CoreClass(name = "Module") | |
| 28 public abstract class ModuleNodes { | |
| 29 | |
| 30 @CoreMethod(names = "alias_method", minArgs = 2, maxArgs = 2) | |
| 31 public abstract static class AliasMethodNode extends CoreMethodNode { | |
| 32 | |
| 33 public AliasMethodNode(RubyContext context, SourceSection sourceSection) { | |
| 34 super(context, sourceSection); | |
| 35 } | |
| 36 | |
| 37 public AliasMethodNode(AliasMethodNode prev) { | |
| 38 super(prev); | |
| 39 } | |
| 40 | |
| 41 @Specialization | |
| 42 public RubyModule aliasMethod(RubyModule module, RubySymbol newName, RubySymbol oldName) { | |
| 43 module.alias(newName.toString(), oldName.toString()); | |
| 44 return module; | |
| 45 } | |
| 46 } | |
| 47 | |
| 48 @CoreMethod(names = "append_features", minArgs = 1, maxArgs = 1) | |
| 49 public abstract static class AppendFeaturesNode extends CoreMethodNode { | |
| 50 | |
| 51 public AppendFeaturesNode(RubyContext context, SourceSection sourceSection) { | |
| 52 super(context, sourceSection); | |
| 53 } | |
| 54 | |
| 55 public AppendFeaturesNode(AppendFeaturesNode prev) { | |
| 56 super(prev); | |
| 57 } | |
| 58 | |
| 59 @Specialization | |
| 60 public NilPlaceholder appendFeatures(RubyModule module, RubyModule other) { | |
| 61 module.appendFeatures(other); | |
| 62 return NilPlaceholder.INSTANCE; | |
| 63 } | |
| 64 } | |
| 65 | |
| 66 @CoreMethod(names = "attr_reader", isSplatted = true, appendCallNode = true) | |
| 67 public abstract static class AttrReaderNode extends CoreMethodNode { | |
| 68 | |
| 69 public AttrReaderNode(RubyContext context, SourceSection sourceSection) { | |
| 70 super(context, sourceSection); | |
| 71 } | |
| 72 | |
| 73 public AttrReaderNode(AttrReaderNode prev) { | |
| 74 super(prev); | |
| 75 } | |
| 76 | |
| 77 @Specialization | |
| 78 public NilPlaceholder attrReader(RubyModule module, Object[] args) { | |
| 79 final Node callSite = (Node) args[args.length - 1]; | |
| 80 final SourceSection sourceSection = callSite.getSourceSection(); | |
| 81 | |
| 82 for (int n = 0; n < args.length - 1; n++) { | |
| 83 attrReader(getContext(), sourceSection, module, args[n].toString()); | |
| 84 } | |
| 85 | |
| 86 return NilPlaceholder.INSTANCE; | |
| 87 } | |
| 88 | |
| 89 public static void attrReader(RubyContext context, SourceSection sourceSection, RubyModule module, String name) { | |
| 90 CompilerDirectives.transferToInterpreter(); | |
| 91 | |
| 92 final CheckArityNode checkArity = new CheckArityNode(context, sourceSection, Arity.NO_ARGS); | |
| 93 | |
| 94 final SelfNode self = new SelfNode(context, sourceSection); | |
| 95 final UninitializedReadInstanceVariableNode readInstanceVariable = new UninitializedReadInstanceVariableNode(context, sourceSection, name, self); | |
| 96 | |
| 97 final SequenceNode block = new SequenceNode(context, sourceSection, checkArity, readInstanceVariable); | |
| 98 | |
|
13706
232eb6708943
Ruby: required fixes for moving FrameDescriptor to the RootNode.
Christian Humer <christian.humer@gmail.com>
parents:
13514
diff
changeset
|
99 final RubyRootNode pristineRoot = new RubyRootNode(sourceSection, null, name + "(attr_reader)", block); |
| 13514 | 100 final CallTarget callTarget = Truffle.getRuntime().createCallTarget(NodeUtil.cloneNode(pristineRoot)); |
| 101 final InlinableMethodImplementation methodImplementation = new InlinableMethodImplementation(callTarget, null, new FrameDescriptor(), pristineRoot, true, false); | |
| 102 final RubyMethod method = new RubyMethod(sourceSection, module, new UniqueMethodIdentifier(), null, name, Visibility.PUBLIC, false, methodImplementation); | |
| 103 | |
| 104 module.addMethod(method); | |
| 105 } | |
| 106 } | |
| 107 | |
| 108 @CoreMethod(names = "attr_writer", isSplatted = true, appendCallNode = true) | |
| 109 public abstract static class AttrWriterNode extends CoreMethodNode { | |
| 110 | |
| 111 public AttrWriterNode(RubyContext context, SourceSection sourceSection) { | |
| 112 super(context, sourceSection); | |
| 113 } | |
| 114 | |
| 115 public AttrWriterNode(AttrWriterNode prev) { | |
| 116 super(prev); | |
| 117 } | |
| 118 | |
| 119 @Specialization | |
| 120 public NilPlaceholder attrWriter(RubyModule module, Object[] args) { | |
| 121 final Node callSite = (Node) args[args.length - 1]; | |
| 122 final SourceSection sourceSection = callSite.getSourceSection(); | |
| 123 | |
| 124 for (int n = 0; n < args.length - 1; n++) { | |
| 125 attrWriter(getContext(), sourceSection, module, args[n].toString()); | |
| 126 } | |
| 127 | |
| 128 return NilPlaceholder.INSTANCE; | |
| 129 } | |
| 130 | |
| 131 public static void attrWriter(RubyContext context, SourceSection sourceSection, RubyModule module, String name) { | |
| 132 CompilerDirectives.transferToInterpreter(); | |
| 133 | |
| 134 final CheckArityNode checkArity = new CheckArityNode(context, sourceSection, Arity.ONE_ARG); | |
| 135 | |
| 136 final SelfNode self = new SelfNode(context, sourceSection); | |
| 137 final ReadPreArgumentNode readArgument = new ReadPreArgumentNode(context, sourceSection, 0, false); | |
| 138 final UninitializedWriteInstanceVariableNode writeInstanceVariable = new UninitializedWriteInstanceVariableNode(context, sourceSection, name, self, readArgument); | |
| 139 | |
| 140 final SequenceNode block = new SequenceNode(context, sourceSection, checkArity, writeInstanceVariable); | |
| 141 | |
|
13706
232eb6708943
Ruby: required fixes for moving FrameDescriptor to the RootNode.
Christian Humer <christian.humer@gmail.com>
parents:
13514
diff
changeset
|
142 final RubyRootNode pristineRoot = new RubyRootNode(sourceSection, null, name + "(attr_writer)", block); |
| 13514 | 143 final CallTarget callTarget = Truffle.getRuntime().createCallTarget(NodeUtil.cloneNode(pristineRoot)); |
| 144 final InlinableMethodImplementation methodImplementation = new InlinableMethodImplementation(callTarget, null, new FrameDescriptor(), pristineRoot, true, false); | |
| 145 final RubyMethod method = new RubyMethod(sourceSection, module, new UniqueMethodIdentifier(), null, name + "=", Visibility.PUBLIC, false, methodImplementation); | |
| 146 | |
| 147 module.addMethod(method); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 @CoreMethod(names = {"attr_accessor", "attr"}, isSplatted = true, appendCallNode = true) | |
| 152 public abstract static class AttrAccessorNode extends CoreMethodNode { | |
| 153 | |
| 154 public AttrAccessorNode(RubyContext context, SourceSection sourceSection) { | |
| 155 super(context, sourceSection); | |
| 156 } | |
| 157 | |
| 158 public AttrAccessorNode(AttrAccessorNode prev) { | |
| 159 super(prev); | |
| 160 } | |
| 161 | |
| 162 @Specialization | |
| 163 public NilPlaceholder attrAccessor(RubyModule module, Object[] args) { | |
| 164 final Node callSite = (Node) args[args.length - 1]; | |
| 165 final SourceSection sourceSection = callSite.getSourceSection(); | |
| 166 | |
| 167 for (int n = 0; n < args.length - 1; n++) { | |
| 168 attrAccessor(getContext(), sourceSection, module, args[n].toString()); | |
| 169 } | |
| 170 | |
| 171 return NilPlaceholder.INSTANCE; | |
| 172 } | |
| 173 | |
| 174 public static void attrAccessor(RubyContext context, SourceSection sourceSection, RubyModule module, String name) { | |
| 175 CompilerDirectives.transferToInterpreter(); | |
| 176 AttrReaderNode.attrReader(context, sourceSection, module, name); | |
| 177 AttrWriterNode.attrWriter(context, sourceSection, module, name); | |
| 178 } | |
| 179 | |
| 180 } | |
| 181 | |
| 182 @CoreMethod(names = "class_eval", minArgs = 1, maxArgs = 3) | |
| 183 public abstract static class ClassEvalNode extends CoreMethodNode { | |
| 184 | |
| 185 public ClassEvalNode(RubyContext context, SourceSection sourceSection) { | |
| 186 super(context, sourceSection); | |
| 187 } | |
| 188 | |
| 189 public ClassEvalNode(ClassEvalNode prev) { | |
| 190 super(prev); | |
| 191 } | |
| 192 | |
| 193 @Specialization | |
| 194 public Object classEval(VirtualFrame frame, RubyModule module, RubyString code, @SuppressWarnings("unused") UndefinedPlaceholder file, @SuppressWarnings("unused") UndefinedPlaceholder line) { | |
| 195 final Source source = getContext().getSourceManager().get("(eval)", code.toString()); | |
| 196 return getContext().execute(getContext(), source, ParserContext.MODULE, module, frame.materialize()); | |
| 197 } | |
| 198 | |
| 199 @Specialization | |
| 200 public Object classEval(VirtualFrame frame, RubyModule module, RubyString code, RubyString file, @SuppressWarnings("unused") UndefinedPlaceholder line) { | |
| 201 final Source source = getContext().getSourceManager().get(file.toString(), code.toString()); | |
| 202 return getContext().execute(getContext(), source, ParserContext.MODULE, module, frame.materialize()); | |
| 203 } | |
| 204 | |
| 205 @Specialization | |
| 206 public Object classEval(VirtualFrame frame, RubyModule module, RubyString code, RubyString file, @SuppressWarnings("unused") int line) { | |
| 207 final Source source = getContext().getSourceManager().get(file.toString(), code.toString()); | |
| 208 return getContext().execute(getContext(), source, ParserContext.MODULE, module, frame.materialize()); | |
| 209 } | |
| 210 | |
| 211 } | |
| 212 | |
| 213 @CoreMethod(names = "class_variable_defined?", maxArgs = 0) | |
| 214 public abstract static class ClassVariableDefinedNode extends CoreMethodNode { | |
| 215 | |
| 216 public ClassVariableDefinedNode(RubyContext context, SourceSection sourceSection) { | |
| 217 super(context, sourceSection); | |
| 218 } | |
| 219 | |
| 220 public ClassVariableDefinedNode(ClassVariableDefinedNode prev) { | |
| 221 super(prev); | |
| 222 } | |
| 223 | |
| 224 @Specialization | |
| 225 public boolean isClassVariableDefined(RubyModule module, RubyString name) { | |
| 226 return module.lookupClassVariable(name.toString()) != null; | |
| 227 } | |
| 228 | |
| 229 @Specialization | |
| 230 public boolean isClassVariableDefined(RubyModule module, RubySymbol name) { | |
| 231 return module.lookupClassVariable(name.toString()) != null; | |
| 232 } | |
| 233 | |
| 234 } | |
| 235 | |
| 236 @CoreMethod(names = "constants", maxArgs = 0) | |
| 237 public abstract static class ConstantsNode extends CoreMethodNode { | |
| 238 | |
| 239 public ConstantsNode(RubyContext context, SourceSection sourceSection) { | |
| 240 super(context, sourceSection); | |
| 241 } | |
| 242 | |
| 243 public ConstantsNode(ConstantsNode prev) { | |
| 244 super(prev); | |
| 245 } | |
| 246 | |
| 247 @Specialization | |
| 248 public RubyArray constants(@SuppressWarnings("unused") RubyModule module) { | |
| 249 getContext().implementationMessage("Module#constants returns an empty array"); | |
| 250 return new RubyArray(getContext().getCoreLibrary().getArrayClass()); | |
| 251 } | |
| 252 } | |
| 253 | |
| 254 @CoreMethod(names = "const_defined?", minArgs = 1, maxArgs = 2) | |
| 255 public abstract static class ConstDefinedNode extends CoreMethodNode { | |
| 256 | |
| 257 public ConstDefinedNode(RubyContext context, SourceSection sourceSection) { | |
| 258 super(context, sourceSection); | |
| 259 } | |
| 260 | |
| 261 public ConstDefinedNode(ConstDefinedNode prev) { | |
| 262 super(prev); | |
| 263 } | |
| 264 | |
| 265 @Specialization(order = 1) | |
| 266 public boolean isConstDefined(RubyModule module, RubyString name, @SuppressWarnings("unused") UndefinedPlaceholder inherit) { | |
| 267 return module.lookupConstant(name.toString()) != null; | |
| 268 } | |
| 269 | |
| 270 @Specialization(order = 2) | |
| 271 public boolean isConstDefined(RubyModule module, RubyString name, boolean inherit) { | |
| 272 if (inherit) { | |
| 273 return module.lookupConstant(name.toString()) != null; | |
| 274 } else { | |
| 275 return module.getConstants().containsKey(name.toString()); | |
| 276 } | |
| 277 } | |
| 278 | |
| 279 @Specialization(order = 3) | |
| 280 public boolean isConstDefined(RubyModule module, RubySymbol name, @SuppressWarnings("unused") UndefinedPlaceholder inherit) { | |
| 281 return module.lookupConstant(name.toString()) != null; | |
| 282 } | |
| 283 | |
| 284 public boolean isConstDefined(RubyModule module, RubySymbol name, boolean inherit) { | |
| 285 if (inherit) { | |
| 286 return module.lookupConstant(name.toString()) != null; | |
| 287 } else { | |
| 288 return module.getConstants().containsKey(name.toString()); | |
| 289 } | |
| 290 } | |
| 291 | |
| 292 } | |
| 293 | |
| 294 @CoreMethod(names = "define_method", needsBlock = true, minArgs = 1, maxArgs = 2) | |
| 295 public abstract static class DefineMethodNode extends CoreMethodNode { | |
| 296 | |
| 297 public DefineMethodNode(RubyContext context, SourceSection sourceSection) { | |
| 298 super(context, sourceSection); | |
| 299 } | |
| 300 | |
| 301 public DefineMethodNode(DefineMethodNode prev) { | |
| 302 super(prev); | |
| 303 } | |
| 304 | |
| 305 @Specialization(order = 1) | |
| 306 public RubyMethod defineMethod(RubyModule module, RubyString name, @SuppressWarnings("unused") UndefinedPlaceholder proc, RubyProc block) { | |
| 307 final RubyMethod method = block.getMethod(); | |
| 308 module.addMethod(method.withNewName(name.toString())); | |
| 309 return method; | |
| 310 } | |
| 311 | |
| 312 @Specialization(order = 2) | |
| 313 public RubyMethod defineMethod(RubyModule module, RubyString name, RubyProc proc, @SuppressWarnings("unused") UndefinedPlaceholder block) { | |
| 314 final RubyMethod method = proc.getMethod(); | |
| 315 module.addMethod(method.withNewName(name.toString())); | |
| 316 return method; | |
| 317 } | |
| 318 | |
| 319 @Specialization(order = 3) | |
| 320 public RubyMethod defineMethod(RubyModule module, RubySymbol name, @SuppressWarnings("unused") UndefinedPlaceholder proc, RubyProc block) { | |
| 321 final RubyMethod method = block.getMethod(); | |
| 322 module.addMethod(method.withNewName(name.toString())); | |
| 323 return method; | |
| 324 } | |
| 325 | |
| 326 @Specialization(order = 4) | |
| 327 public RubyMethod defineMethod(RubyModule module, RubySymbol name, RubyProc proc, @SuppressWarnings("unused") UndefinedPlaceholder block) { | |
| 328 final RubyMethod method = proc.getMethod(); | |
| 329 module.addMethod(method.withNewName(name.toString())); | |
| 330 return method; | |
| 331 } | |
| 332 | |
| 333 } | |
| 334 | |
| 335 @CoreMethod(names = "include", isSplatted = true, minArgs = 1) | |
| 336 public abstract static class IncludeNode extends CoreMethodNode { | |
| 337 | |
| 338 public IncludeNode(RubyContext context, SourceSection sourceSection) { | |
| 339 super(context, sourceSection); | |
| 340 } | |
| 341 | |
| 342 public IncludeNode(IncludeNode prev) { | |
| 343 super(prev); | |
| 344 } | |
| 345 | |
| 346 @Specialization | |
| 347 public NilPlaceholder include(RubyModule module, Object[] args) { | |
| 348 // Note that we traverse the arguments backwards | |
| 349 | |
| 350 for (int n = args.length - 1; n >= 0; n--) { | |
| 351 if (args[n] instanceof RubyModule) { | |
| 352 final RubyModule included = (RubyModule) args[n]; | |
| 353 | |
| 354 // Note that we do appear to do full method lookup here | |
| 355 included.getLookupNode().lookupMethod("append_features").call(null, included, null, module); | |
| 356 | |
| 357 // TODO(cs): call included hook | |
| 358 } | |
| 359 } | |
| 360 | |
| 361 return NilPlaceholder.INSTANCE; | |
| 362 } | |
| 363 } | |
| 364 | |
| 365 @CoreMethod(names = "method_defined?", minArgs = 1, maxArgs = 2) | |
| 366 public abstract static class MethodDefinedNode extends CoreMethodNode { | |
| 367 | |
| 368 public MethodDefinedNode(RubyContext context, SourceSection sourceSection) { | |
| 369 super(context, sourceSection); | |
| 370 } | |
| 371 | |
| 372 public MethodDefinedNode(MethodDefinedNode prev) { | |
| 373 super(prev); | |
| 374 } | |
| 375 | |
| 376 @Specialization(order = 1) | |
| 377 public boolean isMethodDefined(RubyModule module, RubyString name, @SuppressWarnings("unused") UndefinedPlaceholder inherit) { | |
| 378 return module.lookupMethod(name.toString()) != null; | |
| 379 } | |
| 380 | |
| 381 @Specialization(order = 2) | |
| 382 public boolean isMethodDefined(RubyModule module, RubyString name, boolean inherit) { | |
| 383 if (inherit) { | |
| 384 return module.lookupMethod(name.toString()) != null; | |
| 385 } else { | |
| 386 return module.getMethods().containsKey(name.toString()); | |
| 387 } | |
| 388 } | |
| 389 | |
| 390 @Specialization(order = 3) | |
| 391 public boolean isMethodDefined(RubyModule module, RubySymbol name, @SuppressWarnings("unused") UndefinedPlaceholder inherit) { | |
| 392 return module.lookupMethod(name.toString()) != null; | |
| 393 } | |
| 394 | |
| 395 public boolean isMethodDefined(RubyModule module, RubySymbol name, boolean inherit) { | |
| 396 if (inherit) { | |
| 397 return module.lookupMethod(name.toString()) != null; | |
| 398 } else { | |
| 399 return module.getMethods().containsKey(name.toString()); | |
| 400 } | |
| 401 } | |
| 402 } | |
| 403 | |
| 404 @CoreMethod(names = "module_eval", minArgs = 1, maxArgs = 3) | |
| 405 public abstract static class ModuleEvalNode extends CoreMethodNode { | |
| 406 | |
| 407 public ModuleEvalNode(RubyContext context, SourceSection sourceSection) { | |
| 408 super(context, sourceSection); | |
| 409 } | |
| 410 | |
| 411 public ModuleEvalNode(ModuleEvalNode prev) { | |
| 412 super(prev); | |
| 413 } | |
| 414 | |
| 415 @Specialization | |
| 416 public RubyModule moduleEval(RubyModule module, RubyString code, @SuppressWarnings("unused") Object file, @SuppressWarnings("unused") Object line) { | |
| 417 module.moduleEval(code.toString()); | |
| 418 return module; | |
| 419 } | |
| 420 } | |
| 421 | |
| 422 @CoreMethod(names = "module_function", isSplatted = true) | |
| 423 public abstract static class ModuleFunctionNode extends CoreMethodNode { | |
| 424 | |
| 425 public ModuleFunctionNode(RubyContext context, SourceSection sourceSection) { | |
| 426 super(context, sourceSection); | |
| 427 } | |
| 428 | |
| 429 public ModuleFunctionNode(ModuleFunctionNode prev) { | |
| 430 super(prev); | |
| 431 } | |
| 432 | |
| 433 @Specialization | |
| 434 public NilPlaceholder moduleFunction(VirtualFrame frame, RubyModule module, Object... args) { | |
| 435 if (args.length == 0) { | |
| 436 final Frame unpacked = frame.getCaller().unpack(); | |
| 437 | |
| 438 final FrameSlot slot = unpacked.getFrameDescriptor().findFrameSlot(RubyModule.MODULE_FUNCTION_FLAG_FRAME_SLOT_ID); | |
| 439 | |
| 440 /* | |
| 441 * setObject, even though it's a boolean, so we can getObject and either get the | |
| 442 * default Nil or the boolean value without triggering deoptimization. | |
| 443 */ | |
| 444 | |
| 445 unpacked.setObject(slot, true); | |
| 446 } else { | |
| 447 for (Object argument : args) { | |
| 448 final String methodName = argument.toString(); | |
| 449 module.getSingletonClass().addMethod(module.lookupMethod(methodName)); | |
| 450 } | |
| 451 } | |
| 452 | |
| 453 return NilPlaceholder.INSTANCE; | |
| 454 } | |
| 455 } | |
| 456 | |
| 457 @CoreMethod(names = "public", isSplatted = true) | |
| 458 public abstract static class PublicNode extends CoreMethodNode { | |
| 459 | |
| 460 public PublicNode(RubyContext context, SourceSection sourceSection) { | |
| 461 super(context, sourceSection); | |
| 462 } | |
| 463 | |
| 464 public PublicNode(PublicNode prev) { | |
| 465 super(prev); | |
| 466 } | |
| 467 | |
| 468 @Specialization | |
| 469 public RubyModule doPublic(VirtualFrame frame, RubyModule module, Object... args) { | |
| 470 module.visibilityMethod(frame.getCaller(), args, Visibility.PUBLIC); | |
| 471 return module; | |
| 472 } | |
| 473 } | |
| 474 | |
| 475 @CoreMethod(names = "private", isSplatted = true) | |
| 476 public abstract static class PrivateNode extends CoreMethodNode { | |
| 477 | |
| 478 public PrivateNode(RubyContext context, SourceSection sourceSection) { | |
| 479 super(context, sourceSection); | |
| 480 } | |
| 481 | |
| 482 public PrivateNode(PrivateNode prev) { | |
| 483 super(prev); | |
| 484 } | |
| 485 | |
| 486 @Specialization | |
| 487 public RubyModule doPrivate(VirtualFrame frame, RubyModule module, Object... args) { | |
| 488 module.visibilityMethod(frame.getCaller(), args, Visibility.PRIVATE); | |
| 489 return module; | |
| 490 } | |
| 491 } | |
| 492 | |
| 493 @CoreMethod(names = "private_class_method", isSplatted = true) | |
| 494 public abstract static class PrivateClassMethodNode extends CoreMethodNode { | |
| 495 | |
| 496 public PrivateClassMethodNode(RubyContext context, SourceSection sourceSection) { | |
| 497 super(context, sourceSection); | |
| 498 } | |
| 499 | |
| 500 public PrivateClassMethodNode(PrivateClassMethodNode prev) { | |
| 501 super(prev); | |
| 502 } | |
| 503 | |
| 504 @Specialization | |
| 505 public RubyModule privateClassMethod(RubyModule module, Object... args) { | |
| 506 final RubyClass moduleSingleton = module.getSingletonClass(); | |
| 507 | |
| 508 for (Object arg : args) { | |
| 509 final RubyMethod method = moduleSingleton.lookupMethod(arg.toString()); | |
| 510 | |
| 511 if (method == null) { | |
| 512 throw new RuntimeException("Couldn't find method " + arg.toString()); | |
| 513 } | |
| 514 | |
| 515 moduleSingleton.addMethod(method.withNewVisibility(Visibility.PRIVATE)); | |
| 516 } | |
| 517 | |
| 518 return module; | |
| 519 } | |
| 520 } | |
| 521 | |
| 522 @CoreMethod(names = "private_constant", isSplatted = true) | |
| 523 public abstract static class PrivateConstantNode extends CoreMethodNode { | |
| 524 | |
| 525 public PrivateConstantNode(RubyContext context, SourceSection sourceSection) { | |
| 526 super(context, sourceSection); | |
| 527 } | |
| 528 | |
| 529 public PrivateConstantNode(PrivateConstantNode prev) { | |
| 530 super(prev); | |
| 531 } | |
| 532 | |
| 533 @Specialization | |
| 534 public RubyModule privateConstnat(RubyModule module, @SuppressWarnings("unused") Object... args) { | |
| 535 getContext().implementationMessage("private_constant does nothing at the moment"); | |
| 536 return module; | |
| 537 } | |
| 538 } | |
| 539 | |
| 540 @CoreMethod(names = "protected", isSplatted = true) | |
| 541 public abstract static class ProtectedNode extends CoreMethodNode { | |
| 542 | |
| 543 public ProtectedNode(RubyContext context, SourceSection sourceSection) { | |
| 544 super(context, sourceSection); | |
| 545 } | |
| 546 | |
| 547 public ProtectedNode(ProtectedNode prev) { | |
| 548 super(prev); | |
| 549 } | |
| 550 | |
| 551 @Specialization | |
| 552 public RubyModule doProtected(RubyModule module, @SuppressWarnings("unused") Object... args) { | |
| 553 getContext().implementationMessage("protected does nothing at the moment"); | |
| 554 return module; | |
| 555 } | |
| 556 } | |
| 557 | |
| 558 @CoreMethod(names = "remove_class_variable", minArgs = 1, maxArgs = 1) | |
| 559 public abstract static class RemoveClassVariableNode extends CoreMethodNode { | |
| 560 | |
| 561 public RemoveClassVariableNode(RubyContext context, SourceSection sourceSection) { | |
| 562 super(context, sourceSection); | |
| 563 } | |
| 564 | |
| 565 public RemoveClassVariableNode(RemoveClassVariableNode prev) { | |
| 566 super(prev); | |
| 567 } | |
| 568 | |
| 569 @Specialization | |
| 570 public RubyModule removeClassVariable(RubyModule module, RubyString name) { | |
| 571 module.removeClassVariable(name.toString()); | |
| 572 return module; | |
| 573 } | |
| 574 | |
| 575 @Specialization | |
| 576 public RubyModule removeClassVariable(RubyModule module, RubySymbol name) { | |
| 577 module.removeClassVariable(name.toString()); | |
| 578 return module; | |
| 579 } | |
| 580 | |
| 581 } | |
| 582 | |
| 583 @CoreMethod(names = "remove_method", minArgs = 1, maxArgs = 1) | |
| 584 public abstract static class RemoveMethodNode extends CoreMethodNode { | |
| 585 | |
| 586 public RemoveMethodNode(RubyContext context, SourceSection sourceSection) { | |
| 587 super(context, sourceSection); | |
| 588 } | |
| 589 | |
| 590 public RemoveMethodNode(RemoveMethodNode prev) { | |
| 591 super(prev); | |
| 592 } | |
| 593 | |
| 594 @Specialization | |
| 595 public RubyModule removeMethod(RubyModule module, RubyString name) { | |
| 596 module.removeMethod(name.toString()); | |
| 597 return module; | |
| 598 } | |
| 599 | |
| 600 @Specialization | |
| 601 public RubyModule removeMethod(RubyModule module, RubySymbol name) { | |
| 602 module.removeMethod(name.toString()); | |
| 603 return module; | |
| 604 } | |
| 605 | |
| 606 } | |
| 607 | |
| 608 @CoreMethod(names = "to_s", maxArgs = 0) | |
| 609 public abstract static class ToSNode extends CoreMethodNode { | |
| 610 | |
| 611 public ToSNode(RubyContext context, SourceSection sourceSection) { | |
| 612 super(context, sourceSection); | |
| 613 } | |
| 614 | |
| 615 public ToSNode(ToSNode prev) { | |
| 616 super(prev); | |
| 617 } | |
| 618 | |
| 619 @Specialization | |
| 620 public RubyString toS(RubyModule module) { | |
| 621 return getContext().makeString(module.getName()); | |
| 622 } | |
| 623 } | |
| 624 | |
| 625 @CoreMethod(names = "undef_method", minArgs = 1, maxArgs = 1) | |
| 626 public abstract static class UndefMethodNode extends CoreMethodNode { | |
| 627 | |
| 628 public UndefMethodNode(RubyContext context, SourceSection sourceSection) { | |
| 629 super(context, sourceSection); | |
| 630 } | |
| 631 | |
| 632 public UndefMethodNode(UndefMethodNode prev) { | |
| 633 super(prev); | |
| 634 } | |
| 635 | |
| 636 @Specialization | |
| 637 public RubyModule undefMethod(RubyModule module, RubyString name) { | |
| 638 final RubyMethod method = module.lookupMethod(name.toString()); | |
| 639 module.undefMethod(method); | |
| 640 return module; | |
| 641 } | |
| 642 | |
| 643 @Specialization | |
| 644 public RubyModule undefMethod(RubyModule module, RubySymbol name) { | |
| 645 final RubyMethod method = module.lookupMethod(name.toString()); | |
| 646 module.undefMethod(method); | |
| 647 return module; | |
| 648 } | |
| 649 | |
| 650 } | |
| 651 | |
| 652 } |