1/* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import { 17 isCallSignatureDeclaration, isConstructSignatureDeclaration, isHeritageClause, isIndexSignatureDeclaration, 18 isMethodSignature, isPropertySignature, isTypeParameterDeclaration 19} from 'typescript'; 20import type { InterfaceDeclaration, SourceFile } from 'typescript'; 21import { getExportKeyword } from '../common/commonUtils'; 22import { getCallSignatureDeclaration } from './callSignatureDeclaration'; 23import type { CallSignatureEntity } from './callSignatureDeclaration'; 24import { getConstructorDeclaration } from './constructorDeclaration'; 25import type { ConstructorEntity } from './constructorDeclaration'; 26import { getHeritageClauseDeclaration } from './heritageClauseDeclaration'; 27import type { HeritageClauseEntity } from './heritageClauseDeclaration'; 28import { getIndexSignatureDeclaration } from './indexSignatureDeclaration'; 29import type { IndexSignatureEntity } from './indexSignatureDeclaration'; 30import { getMethodSignatureDeclaration } from './methodSignatureDeclaration'; 31import type { MethodSignatureEntity } from './methodSignatureDeclaration'; 32import { getPropertySignatureDeclaration } from './propertySignatureDeclaration'; 33import type { PropertySignatureEntity } from './propertySignatureDeclaration'; 34import { getTypeParameterDeclaration } from './typeParameterDeclaration'; 35import type { TypeParameterEntity } from './typeParameterDeclaration'; 36 37interface SubstepInterfaceEntity { 38 interfaceName: string, 39 heritageClauses: Array<HeritageClauseEntity>, 40 typeParameters: Array<TypeParameterEntity>, 41 interfaceConstructors: Array<Array<ConstructorEntity>>, 42 interfaceMethodSignature: Map<string, Array<MethodSignatureEntity>>, 43 interfacePropertySignatures: Array<PropertySignatureEntity>, 44 callSignatures: Array<CallSignatureEntity>, 45 indexSignature: Array<IndexSignatureEntity> 46} 47 48interface SubstepGetClassparam { 49 interfaceNode: InterfaceDeclaration, 50 sourceFile: SourceFile, 51 heritageClauses: Array<HeritageClauseEntity> 52} 53export interface InterfaceEntity { 54 interfaceName: string, 55 typeParameters: Array<TypeParameterEntity>, 56 heritageClauses: Array<HeritageClauseEntity>, 57 interfaceConstructors: Array<Array<ConstructorEntity>>, 58 interfaceMethodSignature: Map<string, Array<MethodSignatureEntity>>, 59 interfacePropertySignatures: Array<PropertySignatureEntity>, 60 callSignatures: Array<CallSignatureEntity>, 61 exportModifiers: Array<number>, 62 indexSignature: Array<IndexSignatureEntity> 63} 64 65/** 66 * get interface info 67 * @param interfaceNode 68 * @param sourceFile 69 * @returns 70 */ 71export function getInterfaceDeclaration(interfaceNode: InterfaceDeclaration, sourceFile: SourceFile): InterfaceEntity { 72 let exportModifiers: Array<number> = []; 73 if (interfaceNode.modifiers !== undefined) { 74 exportModifiers = getExportKeyword(interfaceNode.modifiers); 75 } 76 77 const heritageClauses: Array<HeritageClauseEntity> = []; 78 79 if (interfaceNode.heritageClauses !== undefined) { 80 interfaceNode.heritageClauses.forEach(value => { 81 heritageClauses.push(getHeritageClauseDeclaration(value, sourceFile)); 82 }); 83 } 84 const SubstepInterfaceEntitys: SubstepInterfaceEntity = substepGetInterface({ 85 interfaceNode, 86 sourceFile, 87 heritageClauses 88 }); 89 90 return { 91 ...SubstepInterfaceEntitys, 92 exportModifiers 93 }; 94} 95 96/** 97 * get some interface info 98 * @param substepGetClassparam 99 * @returns 100 */ 101function substepGetInterface(substepGetClassparam: SubstepGetClassparam): SubstepInterfaceEntity { 102 const { interfaceNode, sourceFile, heritageClauses } = substepGetClassparam; 103 const interfaceName = interfaceNode.name.escapedText.toString(); 104 const interfaceConstructors: Array<Array<ConstructorEntity>> = []; 105 const interfaceMethodSignature: Map<string, Array<MethodSignatureEntity>> = new Map<string, Array<MethodSignatureEntity>>(); 106 const interfacePropertySignatures: Array<PropertySignatureEntity> = []; 107 const callSignature: Array<CallSignatureEntity> = []; 108 const typeParameters: Array<TypeParameterEntity> = []; 109 const indexSignature: Array<IndexSignatureEntity> = []; 110 interfaceNode.members.forEach(value => { 111 if (isPropertySignature(value)) { 112 interfacePropertySignatures.push(getPropertySignatureDeclaration(value, sourceFile)); 113 } else if (isMethodSignature(value)) { 114 const methodSignature = getMethodSignatureDeclaration(value, sourceFile); 115 if (interfaceMethodSignature.get(methodSignature.functionName) !== undefined) { 116 interfaceMethodSignature.get(methodSignature.functionName)?.push(methodSignature); 117 } else { 118 const methodSignatureArray: Array<MethodSignatureEntity> = []; 119 methodSignatureArray.push(methodSignature); 120 interfaceMethodSignature.set(methodSignature.functionName, methodSignatureArray); 121 } 122 } else if (isHeritageClause(value)) { 123 heritageClauses.push(getHeritageClauseDeclaration(value, sourceFile)); 124 } else if (isConstructSignatureDeclaration(value)) { 125 interfaceConstructors.push(getConstructorDeclaration(value, sourceFile)); 126 } else if (isCallSignatureDeclaration(value)) { 127 callSignature.push(getCallSignatureDeclaration(value, sourceFile)); 128 } else if (isTypeParameterDeclaration(value)) { 129 typeParameters.push(getTypeParameterDeclaration(value, sourceFile)); 130 } else if (isIndexSignatureDeclaration(value)) { 131 indexSignature.push(getIndexSignatureDeclaration(value, sourceFile)); 132 } else { 133 console.log('--------------------------- uncaught interface type start -----------------------'); 134 console.log('interfaceName: ' + interfaceName); 135 console.log(value); 136 console.log('--------------------------- uncaught interface type end -----------------------'); 137 } 138 }); 139 return { 140 interfaceName, 141 typeParameters, 142 heritageClauses, 143 interfaceConstructors, 144 interfaceMethodSignature, 145 interfacePropertySignatures, 146 callSignatures: callSignature, 147 indexSignature 148 }; 149} 150