cls-decl.template

// Copyright (C) 2018 Leo Balter. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/*---
path: language/statements/class/private-methods/
name: private method definitions in a class declaration
features: [class, class-methods-private]
info: |
  ClassElement :
    MethodDefinition
    ...
    ;

  ClassElementName :
    PropertyName
    PrivateName

  PrivateName ::
    # IdentifierName

  MethodDefinition :
    ClassElementName ( UniqueFormalParameters ) { FunctionBody }
    GeneratorMethod
    AsyncMethod
    AsyncGeneratorMethod 
    get ClassElementName () { FunctionBody }
    set ClassElementName ( PropertySetParameterList ) { FunctionBody }
  
  GeneratorMethod :
    * ClassElementName ( UniqueFormalParameters ){GeneratorBody}

  AsyncMethod :
    async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }

  AsyncGeneratorMethod :
    async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }

  ---

  InitializeClassElements ( F, proto )

  ...
  5. For each item element in order from elements,
    a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
    b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
      i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
      ii. Perform ? DefineClassElement(receiver, element).

  InitializeInstanceElements ( O, constructor )

  ...
  3. Let elements be the value of F's [[Elements]] internal slot.
  4. For each item element in order from elements,
    a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
      i. Perform ? DefineClassElement(O, element).

  DefineClassElement (receiver, element)

  ...
  6. If key is a Private Name,
    a. Perform ? PrivateFieldDefine(receiver, key, descriptor).

  PrivateFieldDefine (P, O, desc)

  ...
  6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].

esid: prod-MethodDefinition
---*/

/*** template notes
 * method should always be #m
 * the template provides c.ref() for external reference
 */

function hasOwnProperty(obj, name) {
  return Object.prototype.hasOwnProperty.call(obj, name);
}

class C {
  /*{ element }*/

  get ref() { return this.#m; }

  constructor() {
    assert.sameValue(
      hasOwnProperty(this, '#m'), false,
      'private methods are defined in an special internal slot and cannot be found as own properties'
    );
    assert.sameValue(typeof this.#m, 'function');
    assert.sameValue(this.ref(), this.#m, 'returns the same value');

    /*{ constructor }*/
  }
}

var c = new C();
var other = new C();

assert.sameValue(
  hasOwnProperty(C.prototype, '#m'), false,
  'method is not defined in the prototype'
);

assert.sameValue(
  hasOwnProperty(C, '#m'), false,
  'method is not defined in the contructor'
);

assert.sameValue(
  hasOwnProperty(c, '#m'), false,
  'method cannot be seen outside of the class'
);

/***
 * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
 * 
 * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
 * ...
 */
assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');

/*{ assertions }*/