किसी तरीके को ऐब्स्ट्रैक्ट के तौर पर मार्क करता है. goog.abstractMethod के तौर पर किसी तरीके को सेट करने के तरीके की तरह ही, कंपाइलर @abstract के साथ एनोटेट किए गए तरीकों को हटा सकता है, ताकि कोड का साइज़ कम किया जा सके.

अगर @abstract के तौर पर मार्क की गई किसी तरीके का लागू करने का तरीका खाली नहीं है, तो कंपाइलर एक चेतावनी देता है.

/** @abstract */
foo.MyClass.prototype.abstractMethod = function() {};

इस विकल्प का इस्तेमाल करके, किसी वैरिएबल को सिर्फ़ पढ़ने के लिए सेट किया जाता है. कंपाइलर, @const वैरिएबल को इनलाइन कर सकता है. इससे JavaScript कोड को ऑप्टिमाइज़ किया जा सकता है.

टाइप का एलान करना ज़रूरी नहीं है.

अगर @const के तौर पर मार्क किए गए किसी वैरिएबल को एक से ज़्यादा बार वैल्यू असाइन की जाती है, तो कंपाइलर एक चेतावनी दिखाता है. अगर वैरिएबल कोई ऑब्जेक्ट है, तो ध्यान दें कि कंपाइलर, ऑब्जेक्ट की प्रॉपर्टी में बदलाव करने से नहीं रोकता है.

/** @const */ var MY_BEER = 'stout';

/**
 * My namespace's favorite kind of beer.
 * @const {string}
 */
mynamespace.MY_BEER = 'stout';

/** @const */ MyClass.MY_BEER = 'stout';

किसी फ़ंक्शन को कंस्ट्रक्टर के तौर पर मार्क करता है. कंपाइलर को new कीवर्ड के साथ इस्तेमाल किए जाने वाले किसी भी फ़ंक्शन के लिए, @constructor एनोटेशन की ज़रूरत होती है

उदाहरण के लिए:

/**
 * A rectangle.
 * @constructor
 */
function GM_Rect() {
  ...
}

उदाहरण के लिए:

/** @define {boolean} */
var ENABLE_DEBUG = true;

/** @define {boolean} */
goog.userAgent.ASSUME_IE = false;

किसी फ़ंक्शन, तरीके या प्रॉपर्टी को इस तरह से मार्क करता है कि उसका इस्तेमाल करने पर, कंपाइलर की चेतावनी दिखे. इससे पता चलता है कि अब इसका इस्तेमाल नहीं किया जाना चाहिए.

उदाहरण के लिए:

/**
 * Determines whether a node is a field.
 * @return {boolean} True if the contents of
 *     the element are editable, but the element
 *     itself is not.
 * @deprecated Use isField().
 */
BN_EditUtil.isTopEditableField = function(node) {
  ...
};

@dict का इस्तेमाल, अलग-अलग प्रॉपर्टी वाले ऑब्जेक्ट बनाने के लिए किया जाता है. जब किसी कंस्ट्रक्टर (उदाहरण में Foo) को @dict के साथ एनोटेट किया जाता है, तब Foo ऑब्जेक्ट की प्रॉपर्टी ऐक्सेस करने के लिए, सिर्फ़ ब्रैकेट नोटेशन का इस्तेमाल किया जा सकता है. एनोटेशन का इस्तेमाल सीधे तौर पर ऑब्जेक्ट लिटरल पर भी किया जा सकता है.

उदाहरण के लिए:

/**
 * @constructor
 * @dict
 */
function Foo() {}
var obj1 = new Foo();
obj1['x'] = 123;
obj1.x = 234;  // warning

var obj2 = /** @dict */ { 'x': 321 };
obj2.x = 123;  // warning

यह enum का टाइप तय करता है. एनम एक ऐसा ऑब्जेक्ट होता है जिसकी प्रॉपर्टी, मिलते-जुलते कॉन्स्टेंट का एक सेट बनाती हैं. @enum टैग के बाद, टाइप एक्सप्रेशन होना चाहिए.

किसी enum का टाइप लेबल, enum की हर प्रॉपर्टी पर लागू होता है. उदाहरण के लिए, अगर किसी enum का टाइप number है, तो उसकी हर प्रॉपर्टी एक संख्या होनी चाहिए. अगर किसी enum का टाइप शामिल नहीं किया जाता है, तो number को डिफ़ॉल्ट टाइप माना जाता है.

उदाहरण के लिए:

/**
 * Enum for tri-state values.
 * @enum {number}
 */
project.TriState = {
  TRUE: 1,
  FALSE: -1,
  MAYBE: 0
};

यह कोड दिया गया है

/** @export */
foo.MyPublicClass.prototype.myPublicMethod = function() {
  // ...
};

जब कंपाइलर को --generate_exports फ़्लैग के साथ चलाया जाता है, तो यह कोड जनरेट करेगा:

goog.exportProperty(foo.MyPublicClass.prototype, 'myPublicMethod',
  foo.MyPublicClass.prototype.myPublicMethod);

इससे सिंबल, बिना कंपाइल किए गए कोड में एक्सपोर्ट हो जाएंगे. /** @export {SomeType} */ को इस तरह लिखा जा सकता है

/**
 * @export
 * @type {SomeType}
 */

@export एनोटेशन का इस्तेमाल करने वाले कोड को इनमें से कोई एक काम करना होगा

1. closure/base.js शामिल करें या
2. goog.exportSymbol और goog.exportProperty, दोनों को एक ही तरीके से तय किया गया हो. साथ ही, उनके कोडबेस में एक ही सिग्नेचर का इस्तेमाल किया गया हो.

इस एनोटेशन का इस्तेमाल, किसी क्लास या इंटरफ़ेस को दूसरी क्लास से इनहेरिट करने के लिए किया जाता है. @extends के तौर पर मार्क की गई क्लास को @constructor या @interface के तौर पर भी मार्क किया जाना चाहिए.

ध्यान दें: @extends से, किसी क्लास को दूसरी क्लास से इनहेरिट नहीं किया जा सकता. एनोटेशन से कंपाइलर को यह पता चलता है कि टाइप की जांच के दौरान, वह एक क्लास को दूसरी क्लास की सबक्लास के तौर पर मान सकता है.

इनहेरिटेंस को लागू करने के उदाहरण के लिए, Closure Library फ़ंक्शन goog.inherits() देखें.

उदाहरण के लिए:

/**
 * Immutable empty node list.
 * @constructor
 * @extends {goog.ds.BasicNodeList}
 */
goog.ds.EmptyNodeList = function() {
  ...
};

इससे पता चलता है कि इस क्लास को एक्सटेंड करने की अनुमति नहीं है. तरीकों के लिए, यह बताता है कि किसी भी सबक्लास को उस तरीके को बदलने की अनुमति नहीं है.

उदाहरण के लिए:

/**
 * A class that cannot be extended.
 * @final
 * @constructor
 */
sloth.MyFinalClass = function() { ... }

/**
 * A method that cannot be overridden.
 * @final
 */
sloth.MyFinalClass.prototype.method = function() { ... };

@constructor के साथ इसका इस्तेमाल यह बताने के लिए किया जाता है कि कोई क्लास किसी इंटरफ़ेस को लागू करती है.

अगर किसी कंस्ट्रक्टर को @implements से टैग किया जाता है और फिर इंटरफ़ेस में तय किए गए सभी तरीकों और प्रॉपर्टी को लागू नहीं किया जाता है, तो कंपाइलर एक चेतावनी दिखाता है.

उदाहरण के लिए:

/**
 * A shape.
 * @interface
 */
function Shape() {};
Shape.prototype.draw = function() {};

/**
 * @constructor
 * @implements {Shape}
 */
function Square() {};
Square.prototype.draw = function() {
  ...
};

यह एनोटेशन सिर्फ़ externs प्रॉपर्टी के एलान में दिख सकता है. प्रॉपर्टी का टाइप तय किया गया है, लेकिन आपको चेतावनी मिले बिना ही इसे कोई भी टाइप असाइन करने का विकल्प मिलता है. प्रॉपर्टी को ऐक्सेस करने पर, आपको तय किए गए टाइप की वैल्यू वापस मिलती है. उदाहरण के लिए, element.innerHTML को कोई भी टाइप असाइन किया जा सकता है. हालांकि, यह हमेशा एक स्ट्रिंग दिखाता है.

/**
 * @type {string}
 * @implicitCast
 */
Element.prototype.innerHTML;

इससे पता चलता है कि किसी सबक्लास का कोई तरीका या प्रॉपर्टी, सुपरक्लास के किसी तरीके या प्रॉपर्टी को जान-बूझकर छिपाती है. साथ ही, इसका दस्तावेज़ ठीक वैसा ही होता है. ध्यान दें कि @inheritDoc टैग का मतलब @override टैग है.

उदाहरण के लिए:

/** @inheritDoc */
project.SubClass.prototype.toString = function() {
  ...
};

किसी फ़ंक्शन को इंटरफ़ेस के तौर पर मार्क करता है. इंटरफ़ेस, किसी टाइप के ज़रूरी सदस्यों के बारे में बताता है. किसी इंटरफ़ेस को लागू करने वाली किसी भी क्लास को, इंटरफ़ेस के प्रोटोटाइप पर तय किए गए सभी तरीकों और प्रॉपर्टी को लागू करना होगा. @implements देखें.

कंपाइलर यह पुष्टि करता है कि इंटरफ़ेस इंस्टैंटिएट नहीं किए गए हैं. अगर new कीवर्ड का इस्तेमाल किसी इंटरफ़ेस फ़ंक्शन के साथ किया जाता है, तो कंपाइलर एक चेतावनी दिखाता है.

उदाहरण के लिए:

/**
 * A shape.
 * @interface
 */
function Shape() {};
Shape.prototype.draw = function() {};

/**
 * A polygon.
 * @interface
 * @extends {Shape}
 */
function Polygon() {};
Polygon.prototype.getSides = function() {};

इससे पता चलता है कि किसी ऑब्जेक्ट लिटरल की कुंजियों को किसी दूसरे ऑब्जेक्ट की प्रॉपर्टी के तौर पर इस्तेमाल किया जाना चाहिए. यह एनोटेशन सिर्फ़ ऑब्जेक्ट लिटरल पर दिखना चाहिए.

ध्यान दें कि ब्रेसिज़ में मौजूद नाम, अन्य एनोटेशन की तरह टाइप का नाम नहीं है. यह एक ऑब्जेक्ट का नाम है. इससे उस ऑब्जेक्ट का नाम पता चलता है जिसे प्रॉपर्टी दी गई हैं. उदाहरण के लिए, @type {Foo} का मतलब "Foo का एक इंस्टेंस" है, लेकिन @lends {Foo} का मतलब "Foo का कंस्ट्रक्टर" है.

इस एनोटेशन के बारे में ज़्यादा जानकारी के लिए, JSDoc टूलकिट के दस्तावेज़ देखें.

उदाहरण के लिए:

goog.object.extend(
    Button.prototype,
    /** @lends {Button.prototype} */ ({
      isButton: function() { return true; }
    }));

यह कंपाइलर को, मार्क की गई फ़ाइल के कंपाइल किए गए कोड से पहले, उससे जुड़ी टिप्पणी डालने के लिए कहता है. इस एनोटेशन की मदद से, अहम सूचनाओं (जैसे कि कानूनी लाइसेंस या कॉपीराइट टेक्स्ट) को बिना किसी बदलाव के कंपाइल किया जा सकता है. लाइन ब्रेक को बनाए रखा जाता है.

उदाहरण के लिए:

/**
 * @preserve Copyright 2009 SomeThirdParty.
 * Here is the full license text and copyright
 * notice for this file. Note that the notice can span several
 * lines and is only terminated by the closing star and slash:
 */

यह ऐसी प्रॉपर्टी को दिखाता है जिसे कंपाइलर को किसी वैरिएबल में छोटा नहीं करना चाहिए. @nocollapse का मुख्य इस्तेमाल, बदलाव की जा सकने वाली प्रॉपर्टी को एक्सपोर्ट करने की अनुमति देना है. ध्यान दें कि कंपाइलर, बिना कोलैप्स की गई प्रॉपर्टी के नाम अब भी बदल सकता है. अगर आपने किसी ऐसी प्रॉपर्टी को @nocollapse के साथ एनोटेट किया है जो एक ऑब्जेक्ट है, तो उसकी सभी प्रॉपर्टी भी अनकोलैप्स रहेंगी.

उदाहरण के लिए:

/**
 * A namespace.
 * @const
 */
var foo = {};

/**
 * @nocollapse
 */
foo.bar = 42;

window['foobar'] = foo.bar;

इससे पता चलता है कि एलान किए गए बाहरी फ़ंक्शन को कॉल करने से कोई साइड इफ़ेक्ट नहीं होता. इस एनोटेशन की मदद से कंपाइलर, फ़ंक्शन के कॉल हटा सकता है. ऐसा तब होता है, जब रिटर्न वैल्यू का इस्तेमाल नहीं किया जाता. एनोटेशन को सिर्फ़ extern files में इस्तेमाल किया जा सकता है.

उदाहरण के लिए:

/** @nosideeffects */
function noSideEffectsFn1() {}

/** @nosideeffects */
var noSideEffectsFn2 = function() {};

/** @nosideeffects */
a.prototype.noSideEffectsFn3 = function() {};

इससे पता चलता है कि सबक्लास का कोई तरीका या प्रॉपर्टी, सुपरक्लास के किसी तरीके या प्रॉपर्टी को जान-बूझकर छिपाती है. अगर कोई अन्य एनोटेशन शामिल नहीं किया गया है, तो तरीका या प्रॉपर्टी, अपनी सुपरक्लास से एनोटेशन अपने-आप इनहेरिट कर लेती है.

उदाहरण के लिए:

/**
 * @return {string} Human-readable representation of
 *     project.SubClass.
 * @override
 */
project.SubClass.prototype.toString = function() {
  ...
};

किसी सदस्य या प्रॉपर्टी को पैकेज प्राइवेट के तौर पर मार्क करता है. एक ही डायरेक्ट्री में मौजूद कोड, @package के तौर पर मार्क किए गए नामों को ऐक्सेस कर सकता है. खास तौर पर, पैरंट और चाइल्ड डायरेक्ट्री में मौजूद कोड, @package के तौर पर मार्क किए गए नामों को ऐक्सेस नहीं कर सकते.

सार्वजनिक कंस्ट्रक्टर में @package प्रॉपर्टी हो सकती हैं. इनकी मदद से, डायरेक्ट्री से बाहर के कॉल करने वाले लोगों के लिए, इस्तेमाल किए जा सकने वाले तरीकों को सीमित किया जा सकता है. दूसरी ओर, @package कंस्ट्रक्टर के पास सार्वजनिक प्रॉपर्टी हो सकती हैं, ताकि डायरेक्ट्री के बाहर के कॉलर सीधे तौर पर किसी टाइप को इंस्टैंटिएट न कर पाएं.

उदाहरण के लिए:

/**
 * Returns the window object the foreign document resides in.
 *
 * @return {Object} The window object of the peer.
 * @package
 */
goog.net.xpc.CrossPageChannel.prototype.getPeerWindowObject = function() {
  // ...
};

इसका इस्तेमाल, फ़ंक्शन आर्ग्युमेंट के टाइप तय करने के लिए, मेथड, फ़ंक्शन, और कंस्ट्रक्टर की परिभाषाओं के साथ किया जाता है. @param टैग, फ़ंक्शन की परिभाषा में दिए गए पैरामीटर के क्रम में होने चाहिए.

@param टैग के बाद, टाइप एक्सप्रेशन होना चाहिए.

इसके अलावा, पैरामीटर के टाइप को इनलाइन एनोटेट किया जा सकता है (उदाहरण में फ़ंक्शन foo देखें).

उदाहरण के लिए:

/**
 * Queries a Baz for items.
 * @param {number} groupNum Subgroup id to query.
 * @param {string|number|null} term An itemName,
 *     or itemId, or null to search everything.
 */
goog.Baz.prototype.query = function(groupNum, term) {
  ...
};

function foo(/** number */ a, /** number */ b) {
  return a - b + 1;
}

/**
 * @param {{name: string, age: number}} person
 */
function logPerson({name, age}) {
  console.log(`${name} is ${age} years old`);
}

इस कुकी का इस्तेमाल, किसी सदस्य को निजी के तौर पर मार्क करने के लिए किया जाता है. @private के तौर पर मार्क किए गए ग्लोबल वैरिएबल और फ़ंक्शन को सिर्फ़ उसी फ़ाइल का कोड ऐक्सेस कर सकता है. @private के तौर पर मार्क किए गए कंस्ट्रक्टर को सिर्फ़ उसी फ़ाइल में मौजूद कोड और उनके स्टैटिक और इंस्टेंस मेंबर से इंस्टैंशिएट किया जा सकता है.

@private के तौर पर मार्क किए गए कंस्ट्रक्टर की सार्वजनिक स्टैटिक प्रॉपर्टी को भी कहीं से भी ऐक्सेस किया जा सकता है. साथ ही, instanceof ऑपरेटर हमेशा @private सदस्यों को ऐक्सेस कर सकता है.

उदाहरण के लिए:

/**
 * Handlers that are listening to this logger.
 * @private {Array<Function>}
 */
this.handlers_ = [];

इससे पता चलता है कि किसी सदस्य या प्रॉपर्टी को सुरक्षित किया गया है.

@protected के तौर पर मार्क की गई प्रॉपर्टी को इन लोगों के साथ शेयर किया जा सकता है:

• एक ही फ़ाइल में मौजूद सभी कोड
• स्टैटिक मेथड और क्लास की किसी भी सबक्लास के इंस्टेंस मेथड, जिस पर प्रॉपर्टी तय की गई है.

उदाहरण के लिए:

/**
 * Sets the component's root element to the given element.
 * Considered protected and final.
 * @param {Element} element Root element for the component.
 * @protected
 */
goog.ui.Component.prototype.setElementInternal = function(element) {
  // ...
};

यह फ़ंक्शन को स्ट्रक्चरल इंटरफ़ेस के तौर पर मार्क करता है. स्ट्रक्चरल इंटरफ़ेस, नॉमिनल @interface जैसा होता है. हालांकि, इसमें इंप्लिसिट तरीके से लागू करने की अनुमति होती है. इसका मतलब है कि स्ट्रक्चरल इंटरफ़ेस के प्रोटोटाइप पर तय की गई प्रॉपर्टी और मेथड को शामिल करने वाली कोई भी क्लास, स्ट्रक्चरल इंटरफ़ेस को लागू करती है. भले ही, वह @implements टैग का इस्तेमाल करती हो या नहीं. अगर रिकॉर्ड टाइप और ऑब्जेक्ट लिटरल में ज़रूरी प्रॉपर्टी शामिल हैं, तो वे स्ट्रक्चरल इंटरफ़ेस को भी लागू करते हैं.

उदाहरण के लिए:

/**
 * Anything with a draw() method.
 * @record
 */
function Drawable() {};
Drawable.prototype.draw = function() {};

/**
 * A polygon.
 * @param {!Drawable} x
 */
function render(x) { x.draw(); };

var o = { draw() { /* ... */ } };
render(o);

यह तरीके और फ़ंक्शन की परिभाषाओं के रिटर्न टाइप तय करता है. @return टैग के बाद, टाइप एक्सप्रेशन होना चाहिए.

इसके अलावा, रिटर्न टाइप को इनलाइन एनोटेट किया जा सकता है (उदाहरण में फ़ंक्शन foo देखें).

अगर externs में मौजूद नहीं है, तो फ़ंक्शन की कोई रिटर्न वैल्यू नहीं होती. ऐसे में, @return टैग को हटाया जा सकता है. कंपाइलर यह मान लेगा कि फ़ंक्शन undefined को रिटर्न करता है.

उदाहरण के लिए:

/**
 * Returns the ID of the last item.
 * @return {string} The hex ID.
 */
goog.Baz.prototype.getLastId = function() {
  ...
  return id;
};

function /** number */ foo(x) { return x - 1; }

@struct का इस्तेमाल, तय संख्या में प्रॉपर्टी वाले ऑब्जेक्ट बनाने के लिए किया जाता है. जब किसी कंस्ट्रक्टर (उदाहरण में Foo) को @struct के साथ एनोटेट किया जाता है, तब Foo ऑब्जेक्ट की प्रॉपर्टी ऐक्सेस करने के लिए, सिर्फ़ डॉट नोटेशन का इस्तेमाल किया जा सकता है. ब्रैकेट नोटेशन का इस्तेमाल नहीं किया जा सकता. इसके अलावा, कंस्ट्रक्ट किए जाने के बाद, किसी प्रॉपर्टी को Foo इंस्टेंस में नहीं जोड़ा जा सकता. एनोटेशन का इस्तेमाल सीधे तौर पर ऑब्जेक्ट लिटरल पर भी किया जा सकता है.

उदाहरण के लिए:

/**
 * @constructor
 * @struct
 */
function Foo(x) {
  this.x = x;
}
var obj1 = new Foo(123);
var someVar = obj1.x;  // OK
obj1.x = "qwerty";  // OK
obj1['x'] = "asdf";  // warning
obj1.y = 5;  // warning

var obj2 = /** @struct */ { x: 321 };
obj2['x'] = 123;  // warning

जेनेरिक टाइप देखें.

उदाहरण के लिए:

/**
 * @param {T} t
 * @constructor
 * @template T
 */
Container = function(t) { ... };

यह उस ऑब्जेक्ट का टाइप तय करता है जिसे फ़ंक्शन में कीवर्ड this रेफ़र करता है. @this टैग के बाद, टाइप एक्सप्रेशन होना चाहिए.

कंपाइलर की चेतावनियों को रोकने के लिए, आपको @this एनोटेशन का इस्तेमाल करना होगा. ऐसा तब करना होगा, जब this किसी ऐसे फ़ंक्शन में दिखता है जो न तो प्रोटोटाइप मेथड है और न ही @constructor के तौर पर मार्क किया गया फ़ंक्शन है.

उदाहरण के लिए:

chat.RosterWidget.extern('getRosterElement',
    /**
     * Returns the roster widget element.
     * @this {Widget}
     * @return {Element}
     */
    function() {
      return this.getComponent().getElement();
    });

इस टैग का इस्तेमाल, किसी फ़ंक्शन से मिले अपवादों को दस्तावेज़ में शामिल करने के लिए किया जाता है. फ़िलहाल, टाइप चेकर इस जानकारी का इस्तेमाल नहीं करता है. इसका इस्तेमाल सिर्फ़ यह पता लगाने के लिए किया जाता है कि किसी externs फ़ाइल में बताए गए फ़ंक्शन के साइड इफ़ेक्ट हैं या नहीं.

उदाहरण के लिए:

/**
 * @throws {DOMException}
 */
DOMApplicationCache.prototype.swapCache = function() { ... };

यह किसी वैरिएबल, प्रॉपर्टी या एक्सप्रेशन के टाइप की पहचान करता है. @type टैग के बाद, टाइप एक्सप्रेशन होना चाहिए.

किसी वैरिएबल या फ़ंक्शन पैरामीटर का एलान करते समय, टाइप एनोटेशन को इनलाइन लिखा जा सकता है. इसके लिए, {} और @type को शामिल करने की ज़रूरत नहीं है. जैसा कि दूसरे उदाहरण में दिखाया गया है. इस शॉर्टकट का इस्तेमाल सिर्फ़ उन जगहों पर किया जा सकता है जहां किसी वैरिएबल या फ़ंक्शन पैरामीटर का एलान किया गया हो. अगर आपको बाद में टाइप में बदलाव करना है, तो आपको टाइप कास्ट की ज़रूरत होगी.

उदाहरण के लिए:

/**
 * The message hex ID.
 * @type {string}
 */
var hexId = hexId;

var /** string */ name = 'Jamie';
function useSomething(/** (string|number|!Object) */ something) {
...
}

यह ज़्यादा जटिल टाइप के लिए, उपनाम तय करता है. फ़िलहाल, typedefs को सिर्फ़ टॉप लेवल पर तय किया जा सकता है, न कि फ़ंक्शन के अंदर. हमने टाइप इन्फ़रेंस की नई सुविधा में इस समस्या को ठीक कर दिया है.

उदाहरण के लिए:

/** @typedef {(string|number)} */
goog.NumberLike;

/** @param {goog.NumberLike} x A number or a string. */
goog.readNumber = function(x) {
  ...
}

इससे पता चलता है कि क्लास न तो @struct टाइप की है और न ही @dict टाइप की. यह डिफ़ॉल्ट रूप से होता है. इसलिए, आम तौर पर इसे साफ़ तौर पर लिखने की ज़रूरत नहीं होती. हालांकि, अगर class कीवर्ड का इस्तेमाल किया जा रहा है, तो ऐसा करना ज़रूरी है. ये दोनों कीवर्ड, डिफ़ॉल्ट रूप से @struct क्लास जनरेट करते हैं.

उदाहरण के लिए:

/**
 * @constructor
 * @unrestricted
 */
function Foo(x) {
  this.x = x;
}
var obj1 = new Foo(123);
var someVar = obj1.x;  // OK
obj1.x = "qwerty";  // OK
obj1['x'] = "asdf";  // OK
obj1.y = 5;  // OK