private Node processDestructuringElementTarget(ParseTree targetTree) { final Node valueNode; if (targetTree.type == ParseTreeType.DEFAULT_PARAMETER) { // let {key: /** inlineType */ name = default} = something; // let [/** inlineType */ name = default] = something; // processDefaultParameter() knows how to apply the inline JSDoc, if any, to the right node valueNode = processDefaultParameter(targetTree.asDefaultParameter()); } else if (targetTree.type == ParseTreeType.IDENTIFIER_EXPRESSION) { // let {key: /** inlineType */ name} = something // let [/** inlineType */ name] = something // Allow inline JSDoc on the name, since we may well be declaring it here. valueNode = processNameWithInlineJSDoc(targetTree.asIdentifierExpression()); } else { // ({prop: /** string */ ns.a.b} = someObject); // NOTE: CheckJSDoc will report an error for this case, since we want qualified names to be // declared with individual statements, like `/** @type {string} */ ns.a.b;` valueNode = transformNodeWithInlineJsDoc(targetTree); } return valueNode; }
Node processArrayPattern(ArrayPatternTree tree) { maybeWarnForFeature(tree, Feature.ARRAY_DESTRUCTURING); Node node = newNode(Token.ARRAY_PATTERN); for (ParseTree child : tree.elements) { Node elementNode; if (child.type == ParseTreeType.DEFAULT_PARAMETER) { // processDefaultParameter() knows how to find and apply inline JSDoc to the right node elementNode = processDefaultParameter(child.asDefaultParameter()); } else { elementNode = transformNodeWithInlineJsDoc(child); } node.addChildToBack(elementNode); } return node; }
private Node processObjectPatternElement(ParseTree child) { switch (child.type) { case DEFAULT_PARAMETER: // shorthand with a default value // let { /** inlineType */ name = default } = something; return processObjectPatternShorthandWithDefault(child.asDefaultParameter()); case PROPERTY_NAME_ASSIGNMENT: return processObjectPatternPropertyNameAssignment(child.asPropertyNameAssignment()); case COMPUTED_PROPERTY_DEFINITION: // let {[expression]: /** inlineType */ name} = something; ComputedPropertyDefinitionTree computedPropertyDefinition = child.asComputedPropertyDefinition(); return processObjectPatternComputedPropertyDefinition(computedPropertyDefinition); default: // let {...restObject} = someObject; checkState(child.type == ParseTreeType.ASSIGNMENT_REST_ELEMENT, child); maybeWarnForFeature(child, Feature.OBJECT_PATTERN_REST); return processAssignmentRestElement(child.asAssignmentRestElement()); } }
Node processFormalParameterList(FormalParameterListTree tree) { Node params = newNode(Token.PARAM_LIST); if (checkParameters(tree.parameters)) { for (ParseTree param : tree.parameters) { Node paramNode; if (param.type == ParseTreeType.DEFAULT_PARAMETER) { // processDefaultParameter() knows how to find and apply inline JSDoc to the right node paramNode = processDefaultParameter(param.asDefaultParameter()); } else { paramNode = transformNodeWithInlineJsDoc(param); } // Children must be simple names, default parameters, rest // parameters, or destructuring patterns. checkState( paramNode.isName() || paramNode.isRest() || paramNode.isArrayPattern() || paramNode.isObjectPattern() || paramNode.isDefaultValue()); params.addChildToBack(paramNode); } } return params; }
return processDefaultParameter(node.asDefaultParameter()); case REST_PARAMETER: return processRestParameter(node.asRestParameter());
return processDefaultParameter(node.asDefaultParameter()); case REST_PARAMETER: return processRestParameter(node.asRestParameter());