Package com.google.javascript.jscomp

Interface CodingConvention

All Superinterfaces:
Serializable
All Known Implementing Classes:
ChromeCodingConvention, ClosureCodingConvention, CodingConventions.Proxy, GoogleCodingConvention
@Immutable public interface CodingConvention extends Serializable
CodingConvention defines a set of hooks to customize the behavior of the Compiler for a specific team/company.

  • Method Details

    • isConstant

      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.
      Parameters:
      variableName - potentially constant variable name
      Returns:
      true if the name should be treated as a constant.

    • isConstantKey

      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.

    • isValidEnumKey

      boolean isValidEnumKey(String key)
      This checks that a given key may be used as a key for an enum.
      Parameters:
      key - the potential key to an enum
      Returns:
      true if the key may be used as an enum key, false otherwise

    • isOptionalParameter

      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. 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.
      Parameters:
      parameter - The parameter's node.
      Returns:
      true if the parameter should be treated as an optional parameter.

    • isVarArgsParameter

      boolean isVarArgsParameter(Node parameter)
      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.
      Parameters:
      parameter - The parameter's node.
      Returns:
      true if the parameter should be treated as a variable length parameter.

    • isFunctionCallThatAlwaysThrows

      boolean isFunctionCallThatAlwaysThrows(Node n)
      Used by CheckMissingReturn. When a function call always throws an error, it can be the last stm of a block and we don't warn about missing return.

    • isExported

      boolean isExported(String name, boolean local)
      Checks whether a global variable or function name should be treated as exported, or externally referenceable.
      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

      default boolean isExported(String name)
      Equivalent to `isExported(name, true) || isExported(name, false);`

      Should only be used to check if a property is exported. Variables should always use isExported(String, boolean), as in most cases local variables should not be treated as exported.

      Do not override! Unfortunately, that cannot be enforced without making this an abstract class.

    • blockRenamingForProperty

      @Deprecated default boolean blockRenamingForProperty(String name)
      Deprecated.
      since this has a default value and is never checked, you can safely remove any overrides of this method from your coding conventions.
      No-op convention that is never used.

    • getPackageName

      String getPackageName(StaticSourceFile source)
      Returns:
      the package name for the given source file, or null if no package name is known.

    • getClassesDefinedByCall

      CodingConvention.SubclassRelationship getClassesDefinedByCall(Node callNode)
      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.
      Parameters:
      callNode - A CALL node.

    • isClassFactoryCall

      boolean isClassFactoryCall(Node callNode)
      Checks if the given method is a call to a class factory, such a factory returns a unique class.
      Parameters:
      callNode - A CALL node.

    • isSuperClassReference

      boolean isSuperClassReference(String propertyName)
      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_.

    • extractIsModuleFile

      boolean extractIsModuleFile(Node node, Node parent)
      Convenience method for determining if the node indicates the file is a "module" file (a file whose top level symbols are not in global scope).

    • extractClassNameIfProvide

      String extractClassNameIfProvide(Node node, Node parent)
      Convenience method for determining provided dependencies amongst different JS scripts.

    • extractClassNameIfRequire

      String extractClassNameIfRequire(Node node, Node parent)
      Convenience method for determining required dependencies amongst different JS scripts.

    • getExportPropertyFunction

      String getExportPropertyFunction()
      Function name used when exporting properties. Signature: fn(object, publicName, symbol).
      Returns:
      function name.

    • getExportSymbolFunction

      String getExportSymbolFunction()
      Function name used when exporting symbols. Signature: fn(publicPath, object).
      Returns:
      function name.

    • identifyTypeDeclarationCall

      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.

    • applySubclassRelationship

      void applySubclassRelationship(NominalTypeBuilder parent, NominalTypeBuilder child, CodingConvention.SubclassType type)
      In many JS libraries, the function that produces inheritance also adds properties to the superclass and/or subclass.

    • getAbstractMethodName

      String getAbstractMethodName()
      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.
      Returns:
      function name.

    • getSingletonGetterClassName

      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. By default, always returns null. Meant to be overridden by subclasses. addSingletonGetter needs a coding convention because in the general case, it can't be inlined. The function inliner sees that it creates an alias to the given class in an inner closure, and bails out.
      Parameters:
      callNode - A CALL node.

    • applySingletonGetter

      void applySingletonGetter(NominalTypeBuilder classType, FunctionType getterType)
      In many JS libraries, the function that adds a singleton getter to a class adds properties to the class.

    • describeFunctionBind

      CodingConvention.Bind describeFunctionBind(Node n)
      A Bind instance or null.

    • describeFunctionBind

      CodingConvention.Bind describeFunctionBind(Node n, boolean callerChecksTypes, boolean iCheckTypes)
      A Bind instance or null.

      When seeing an expression exp1.bind(recv, arg1, ...); we only know that it's a function bind if exp1 has type function. W/out type info, exp1 has certainly a function type only if it's a function literal.

      If type checking has already happened, exp1's type is attached to the AST node. When iCheckTypes is true, describeFunctionBind looks for that type.

      Parameters:
      callerChecksTypes - Trust that the caller of this method has verified that the bound node has a function type.
      iCheckTypes - Check that the bound node has a function type.

    • describeCachingCall

      CodingConvention.Cache describeCachingCall(Node node)
      Builds a CodingConvention.Cache instance from the given call node and returns that instance, or null if the Node does not resemble a cache utility call.

      This should match calls to a cache utility method. This type of node is specially considered for side-effects since conventionally storing something on a cache object would be seen as a side-effect.

    • isPropertyTestFunction

      boolean isPropertyTestFunction(Node call)
      Whether this CALL function is testing for the existence of a property.

    • isPrototypeAlias

      boolean isPrototypeAlias(Node getProp)
      Whether this GETPROP node is an alias for an object prototype.

    • isPropertyRenameFunction

      boolean isPropertyRenameFunction(Node nameNode)
      Whether this GETPROP or NAME node is the function is returning the string name for a property, but allows renaming.

    • getObjectLiteralCast

      CodingConvention.ObjectLiteralCast getObjectLiteralCast(Node callNode)
      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.
      Parameters:
      callNode - A CALL node.

    • getIndirectlyDeclaredProperties

      Collection<String> getIndirectlyDeclaredProperties()
      Gets a collection of all properties that are defined indirectly on global objects. (For example, Closure defines superClass_ in the goog.inherits call).

    • getAssertionFunctions

      Collection<CodingConvention.AssertionFunctionSpec> getAssertionFunctions()
      Returns the set of AssertionFunction.