docs: function checkVariableLikeDeclaration(node) {
              checkDecorators(node);
              checkSourceElement(node.type);
              // For a computed property, just check the initializer and exit
              // Do not use hasDynamicName here, because that returns false for well known symbols.
              // We want to perform checkComputedPropertyName for all computed properties, including
              // well known symbols.
              if (node.name.kind === 140 /* ComputedPropertyName */) {
                  checkComputedPropertyName(node.name);
                  if (node.initializer) {
                      checkExpressionCached(node.initializer);
                  }
              }
              if (node.kind === 169 /* BindingElement */) {
                  // check computed properties inside property names of binding elements
                  if (node.propertyName && node.propertyName.kind === 140 /* ComputedPropertyName */) {
                      checkComputedPropertyName(node.propertyName);
                  }
                  // check private/protected variable access
                  var parent_11 = node.parent.parent;
                  var parentType = getTypeForBindingElementParent(parent_11);
                  var name_18 = node.propertyName || node.name;
                  var property = getPropertyOfType(parentType, getTextOfPropertyName(name_18));
                  if (parent_11.initializer && property && getParentOfSymbol(property)) {
                      checkClassPropertyAccess(parent_11, parent_11.initializer, parentType, property);
                  }
              }
              // For a binding pattern, check contained binding elements
              if (ts.isBindingPattern(node.name)) {
                  ts.forEach(node.name.elements, checkSourceElement);
              }
              // For a parameter declaration with an initializer, error and exit if the containing function doesn't have a body
              if (node.initializer && ts.getRootDeclaration(node).kind === 142 /* Parameter */ && ts.nodeIsMissing(ts.getContainingFunction(node).body)) {
                  error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation);
                  return;
              }
              // For a binding pattern, validate the initializer and exit
              if (ts.isBindingPattern(node.name)) {
                  // Don't validate for-in initializer as it is already an error
                  if (node.initializer && node.parent.parent.kind !== 207 /* ForInStatement */) {
                      checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), node, /*headMessage*/ undefined);
                      checkParameterInitializer(node);
                  }
                  return;
              }
              var symbol = getSymbolOfNode(node);
              var type = getTypeOfVariableOrParameterOrProperty(symbol);
              if (node === symbol.valueDeclaration) {
                  // Node is the primary declaration of the symbol, just validate the initializer
                  // Don't validate for-in initializer as it is already an error
                  if (node.initializer && node.parent.parent.kind !== 207 /* ForInStatement */) {
                      checkTypeAssignableTo(checkExpressionCached(node.initializer), type, node, /*headMessage*/ undefined);
                      checkParameterInitializer(node);
                  }
              }
              else {
                  // Node is a secondary declaration, check that type is identical to primary declaration and check that
                  // initializer is consistent with type associated with the node
                  var declarationType = getWidenedTypeForVariableLikeDeclaration(node);
                  if (type !== unknownType && declarationType !== unknownType && !isTypeIdenticalTo(type, declarationType)) {
                      error(node.name, ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, ts.declarationNameToString(node.name), typeToString(type), typeToString(declarationType));
                  }
                  if (node.initializer) {
                      checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, /*headMessage*/ undefined);
                  }
                  if (!areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) {
                      error(symbol.valueDeclaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
                      error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name));
                  }
              }
              if (node.kind !== 145 /* PropertyDeclaration */ && node.kind !== 144 /* PropertySignature */) {
                  // We know we don't have a binding pattern or computed name here
                  checkExportsOnMergedDeclarations(node);
                  if (node.kind === 218 /* VariableDeclaration */ || node.kind === 169 /* BindingElement */) {
                      checkVarDeclaredNamesNotShadowed(node);
                  }
                  checkCollisionWithCapturedSuperVariable(node, node.name);
                  checkCollisionWithCapturedThisVariable(node, node.name);
                  checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
                  checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
              }
          }