## com.google.javascript.jscomp
Class CodingConventions.Proxy

    java.lang.Object
      com.google.javascript.jscomp.CodingConventions.Proxy

All Implemented Interfaces:
  CodingConvention, Serializable

Direct Known Subclasses:
  ClosureCodingConvention, GoogleCodingConvention, JqueryCodingConvention

Enclosing class:
  CodingConventions

    public static class CodingConventions.Proxy

extends Object
implements CodingConvention

A convention that wraps another. When you want to support a new library, you should subclass this delegate, and override the methods that you want to customize. This way, a person using jQuery and Closure Library can create a new coding convention by creating a jQueryCodingConvention that delegates to a ClosureCodingConvention that delegates to a DefaultCodingConvention.

See Also:
  Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface com.google.javascript.jscomp.CodingConvention
`CodingConvention.AssertionFunctionSpec, CodingConvention.Bind, CodingConvention.DelegateRelationship, CodingConvention.ObjectLiteralCast, CodingConvention.SubclassRelationship, CodingConvention.SubclassType`

Field Summary
`protected CodingConvention` | `nextConvention`

Constructor Summary
`protected` | `CodingConventions.Proxy(CodingConvention convention)`

Method Summary
`void` | `applyDelegateRelationship(ObjectType delegateSuperclass, ObjectType delegateBase, ObjectType delegator, FunctionType delegateProxy, FunctionType findDelegate)` In many JS libraries, the function that creates a delegate relationship also adds properties to the delegator and delegate base.
`void` | `applySingletonGetter(FunctionType functionType, FunctionType getterType, ObjectType objectType)` In many JS libraries, the function that adds a singleton getter to a class adds properties to the class.
`void` | `applySubclassRelationship(FunctionType parentCtor, FunctionType childCtor, CodingConvention.SubclassType type)` In many JS libraries, the function that produces inheritance also adds properties to the superclass and/or subclass.
`void` | `checkForCallingConventionDefiningCalls(Node n, Map<String,String> delegateCallingConventions)` Checks for function calls that set the calling conventions on delegate methods.
`void` | `defineDelegateProxyPrototypeProperties(JSTypeRegistry registry, Scope scope, List<ObjectType> delegateProxyPrototypes, Map<String,String> delegateCallingConventions)` Defines the delegate proxy prototype properties.
`CodingConvention.Bind` | `describeFunctionBind(Node n)` A Bind instance or null.
`String` | `extractClassNameIfProvide(Node node, Node parent)` Convenience method for determining provided dependencies amongst different js scripts.
`String` | `extractClassNameIfRequire(Node node, Node parent)` Convenience method for determining required dependencies amongst different js scripts.
`String` | `getAbstractMethodName()` Function name for abstract methods.
`Collection<CodingConvention.AssertionFunctionSpec>` | `getAssertionFunctions()` Returns the set of AssertionFunction.
`CodingConvention.SubclassRelationship` | `getClassesDefinedByCall(Node callNode)` Checks if the given method defines a subclass relationship, and if it does, returns information on that relationship.
`CodingConvention.DelegateRelationship` | `getDelegateRelationship(Node callNode)`
`String` | `getDelegateSuperclassName()`
`String` | `getExportPropertyFunction()` Function name used when exporting properties.
`String` | `getExportSymbolFunction()` Function name used when exporting symbols.
`String` | `getGlobalObject()` Gets the name of the global object.
`CodingConvention.ObjectLiteralCast` | `getObjectLiteralCast(NodeTraversal t, Node callNode)` Checks if the given method performs a object literal cast, and if it does, returns information on the cast.
`String` | `getSingletonGetterClassName(Node callNode)` Checks if the given method defines a singleton getter, and if it does, returns the name of the class with the singleton getter.
`List<String>` | `identifyTypeDeclarationCall(Node n)` Checks if the given CALL node is forward-declaring any types, and returns the name of the types if it is.
`boolean` | `isConstant(String variableName)` This checks whether a given variable name, such as a name in all-caps should be treated as if it had the @const annotation.
`boolean` | `isConstantKey(String keyName)` This checks whether a given key of an object literal, such as a name in all-caps should be treated as if it had the @const annotation.
`boolean` | `isExported(String name)` Should be isExported(name, true) || isExported(name, false);
`boolean` | `isExported(String name, boolean local)` Checks whether a global variable or function name should be treated as exported, or externally referenceable.
`boolean` | `isOptionalParameter(Node parameter)` This checks whether a given parameter name should be treated as an optional parameter as far as type checking or function call arg count checking is concerned.
`boolean` | `isPrivate(String name)` Checks whether a name should be considered private.
`boolean` | `isPropertyTestFunction(Node call)` Whether this CALL function is testing for the existence of a property.
`boolean` | `isPrototypeAlias(Node getProp)` Whether this GETPROP node is an alias for an object prototype.
`boolean` | `isSuperClassReference(String propertyName)` Returns true if passed a string referring to the superclass.
`boolean` | `isValidEnumKey(String key)` This checks that a given `key` may be used as a key for an enum.
`boolean` | `isVarArgsParameter(Node parameter)` This checks whether a given parameter should be treated as a marker for a variable argument list function.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### nextConvention

    protected final CodingConvention nextConvention

Constructor Detail

### CodingConventions.Proxy

    protected CodingConventions.Proxy(CodingConvention convention)

Method Detail

### isConstant

    public boolean isConstant(String variableName)

  Description copied from interface: `CodingConvention`
  This checks whether a given variable name, such as a name in all-caps should be treated as if it had the @const annotation.

  Specified by:
    `isConstant` in interface `CodingConvention`
  Parameters:
    `variableName` - potentially constant variable name
  Returns:
    `true` if the name should be treated as a constant.

### isConstantKey

    public boolean isConstantKey(String keyName)

  Description copied from interface: `CodingConvention`
  This checks whether a given key of an object literal, such as a name in all-caps should be treated as if it had the @const annotation.

  Specified by:
    `isConstantKey` in interface `CodingConvention`

### isValidEnumKey

    public boolean isValidEnumKey(String key)

  Description copied from interface: `CodingConvention`
  This checks that a given `key` may be used as a key for an enum.

  Specified by:
    `isValidEnumKey` in interface `CodingConvention`
  Parameters:
    `key` - the potential key to an enum
  Returns:
    `true` if the `key` may be used as an enum key, `false` otherwise

### isOptionalParameter

    public boolean isOptionalParameter(Node parameter)

  Description copied from interface: `CodingConvention`
  This checks whether a given parameter name should be treated as an optional parameter as far as type checking or function call arg count checking is concerned. Note that an optional function parameter may be declared as a simple type and is automatically converted to a union of the declared type and Undefined.

  Specified by:
    `isOptionalParameter` in interface `CodingConvention`
  Parameters:
    `parameter` - The parameter's node.
  Returns:
    `true` if the parameter should be treated as an optional parameter.

### isVarArgsParameter

    public boolean isVarArgsParameter(Node parameter)

  Description copied from interface: `CodingConvention`
  This checks whether a given parameter should be treated as a marker for a variable argument list function. A VarArgs parameter must be the last parameter in a function declaration.

  Specified by:
    `isVarArgsParameter` in interface `CodingConvention`
  Parameters:
    `parameter` - The parameter's node.
  Returns:
    `true` if the parameter should be treated as a variable length parameter.

### isExported

    public boolean isExported(String name,
                              boolean local)

  Description copied from interface: `CodingConvention`
  Checks whether a global variable or function name should be treated as exported, or externally referenceable.

  Specified by:
    `isExported` in interface `CodingConvention`
  Parameters:
    `name` - A global variable or function name.
    `local` - `true` if the name is a local variable.
  Returns:
    `true` if the name should be considered exported.

### isExported

    public final boolean isExported(String name)

  Description copied from interface: `CodingConvention`
  Should be isExported(name, true) || isExported(name, false);

  Specified by:
    `isExported` in interface `CodingConvention`

### isPrivate

    public boolean isPrivate(String name)

  Description copied from interface: `CodingConvention`
  Checks whether a name should be considered private. Private global variables and functions can only be referenced within the source file in which they are declared. Private properties and methods should only be accessed by the class that defines them.

  Specified by:
    `isPrivate` in interface `CodingConvention`
  Parameters:
    `name` - The name of a global variable or function, or a method or property.
  Returns:
    `true` if the name should be considered private.

### getClassesDefinedByCall

    public CodingConvention.SubclassRelationship getClassesDefinedByCall(Node callNode)

  Description copied from interface: `CodingConvention`
  Checks if the given method defines a subclass relationship, and if it does, returns information on that relationship. By default, always returns null. Meant to be overridden by subclasses.

  Specified by:
    `getClassesDefinedByCall` in interface `CodingConvention`
  Parameters:
    `callNode` - A CALL node.

### isSuperClassReference

    public boolean isSuperClassReference(String propertyName)

  Description copied from interface: `CodingConvention`
  Returns true if passed a string referring to the superclass. The string will usually be from the string node at the right of a GETPROP, e.g. this.superClass_.

  Specified by:
    `isSuperClassReference` in interface `CodingConvention`

### extractClassNameIfProvide

    public String extractClassNameIfProvide(Node node,
                                            Node parent)

  Description copied from interface: `CodingConvention`
  Convenience method for determining provided dependencies amongst different js scripts.

  Specified by:
    `extractClassNameIfProvide` in interface `CodingConvention`

### extractClassNameIfRequire

    public String extractClassNameIfRequire(Node node,
                                            Node parent)

  Description copied from interface: `CodingConvention`
  Convenience method for determining required dependencies amongst different js scripts.

  Specified by:
    `extractClassNameIfRequire` in interface `CodingConvention`

### getExportPropertyFunction

    public String getExportPropertyFunction()

  Description copied from interface: `CodingConvention`
  Function name used when exporting properties. Signature: fn(object, publicName, symbol).

  Specified by:
    `getExportPropertyFunction` in interface `CodingConvention`
  Returns:
    function name.

### getExportSymbolFunction

    public String getExportSymbolFunction()

  Description copied from interface: `CodingConvention`
  Function name used when exporting symbols. Signature: fn(publicPath, object).

  Specified by:
    `getExportSymbolFunction` in interface `CodingConvention`
  Returns:
    function name.

### identifyTypeDeclarationCall

    public List<String> identifyTypeDeclarationCall(Node n)

  Description copied from interface: `CodingConvention`
  Checks if the given CALL node is forward-declaring any types, and returns the name of the types if it is.

  Specified by:
    `identifyTypeDeclarationCall` in interface `CodingConvention`

### applySubclassRelationship

    public void applySubclassRelationship(FunctionType parentCtor,
                                          FunctionType childCtor,
                                          CodingConvention.SubclassType type)

  Description copied from interface: `CodingConvention`
  In many JS libraries, the function that produces inheritance also adds properties to the superclass and/or subclass.

  Specified by:
    `applySubclassRelationship` in interface `CodingConvention`

### getAbstractMethodName

    public String getAbstractMethodName()

  Description copied from interface: `CodingConvention`
  Function name for abstract methods. An abstract method can be assigned to an interface method instead of an function expression in order to avoid linter warnings produced by assigning a function without a return value where a return value is expected.

  Specified by:
    `getAbstractMethodName` in interface `CodingConvention`
  Returns:
    function name.

### getSingletonGetterClassName

    public String getSingletonGetterClassName(Node callNode)

  Description copied from interface: `CodingConvention`
  Checks if the given method defines a singleton getter, and if it does, returns the name of the class with the singleton getter. By default, always returns null. Meant to be overridden by subclasses.

  Specified by:
    `getSingletonGetterClassName` in interface `CodingConvention`
  Parameters:
    `callNode` - A CALL node.

### applySingletonGetter

    public void applySingletonGetter(FunctionType functionType,
                                     FunctionType getterType,
                                     ObjectType objectType)

  Description copied from interface: `CodingConvention`
  In many JS libraries, the function that adds a singleton getter to a class adds properties to the class.

  Specified by:
    `applySingletonGetter` in interface `CodingConvention`

### getDelegateRelationship

    public CodingConvention.DelegateRelationship getDelegateRelationship(Node callNode)

  Specified by:
    `getDelegateRelationship` in interface `CodingConvention`

### applyDelegateRelationship

    public void applyDelegateRelationship(ObjectType delegateSuperclass,
                                          ObjectType delegateBase,
                                          ObjectType delegator,
                                          FunctionType delegateProxy,
                                          FunctionType findDelegate)

  Description copied from interface: `CodingConvention`
  In many JS libraries, the function that creates a delegate relationship also adds properties to the delegator and delegate base.

  Specified by:
    `applyDelegateRelationship` in interface `CodingConvention`

### getDelegateSuperclassName

    public String getDelegateSuperclassName()

  Specified by:
    `getDelegateSuperclassName` in interface `CodingConvention`
  Returns:
    the name of the delegate superclass.

### checkForCallingConventionDefiningCalls

    public void checkForCallingConventionDefiningCalls(Node n,
                                                       Map<String,String> delegateCallingConventions)

  Description copied from interface: `CodingConvention`
  Checks for function calls that set the calling conventions on delegate methods.

  Specified by:
    `checkForCallingConventionDefiningCalls` in interface `CodingConvention`

### defineDelegateProxyPrototypeProperties

    public void defineDelegateProxyPrototypeProperties(JSTypeRegistry registry,
                                                       Scope scope,
                                                       List<ObjectType> delegateProxyPrototypes,
                                                       Map<String,String> delegateCallingConventions)

  Description copied from interface: `CodingConvention`
  Defines the delegate proxy prototype properties. Their types depend on properties of the delegate base methods.

  Specified by:
    `defineDelegateProxyPrototypeProperties` in interface `CodingConvention`
    `delegateProxyPrototypes` - List of delegate proxy prototypes.

### getGlobalObject

    public String getGlobalObject()

  Description copied from interface: `CodingConvention`
  Gets the name of the global object.

  Specified by:
    `getGlobalObject` in interface `CodingConvention`

### getAssertionFunctions

    public Collection<CodingConvention.AssertionFunctionSpec> getAssertionFunctions()

  Description copied from interface: `CodingConvention`
  Returns the set of AssertionFunction.

  Specified by:
    `getAssertionFunctions` in interface `CodingConvention`

### describeFunctionBind

    public CodingConvention.Bind describeFunctionBind(Node n)

  Description copied from interface: `CodingConvention`
  A Bind instance or null.

  Specified by:
    `describeFunctionBind` in interface `CodingConvention`

### isPropertyTestFunction

    public boolean isPropertyTestFunction(Node call)

  Description copied from interface: `CodingConvention`
  Whether this CALL function is testing for the existence of a property.

  Specified by:
    `isPropertyTestFunction` in interface `CodingConvention`

### isPrototypeAlias

    public boolean isPrototypeAlias(Node getProp)

  Description copied from interface: `CodingConvention`
  Whether this GETPROP node is an alias for an object prototype.

  Specified by:
    `isPrototypeAlias` in interface `CodingConvention`

### getObjectLiteralCast

    public CodingConvention.ObjectLiteralCast getObjectLiteralCast(NodeTraversal t,
                                                                   Node callNode)

  Description copied from interface: `CodingConvention`
  Checks if the given method performs a object literal cast, and if it does, returns information on the cast. By default, always returns null. Meant to be overridden by subclasses.

  Specified by:
    `getObjectLiteralCast` in interface `CodingConvention`
  Parameters:
    `t` - The node traversal.
    `callNode` - A CALL node.