From 366eec524c32f88cbc5fab69120c497f5ccd0b19 Mon Sep 17 00:00:00 2001 From: ZhongNing Date: Thu, 12 Jun 2025 17:31:31 +0800 Subject: [PATCH] Fix for ArrayTypeImmutable Issue:https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/ICEFLY Test scenarios:fix issue Signed-off-by: ZhongNing --- ets2panda/linter/src/lib/TypeScriptLinter.ts | 96 +-- .../test/main/arkts-array-type-immutable.ets | 121 +++- ...arkts-array-type-immutable.ets.arkts2.json | 580 ++++++++++++++++++ .../main/arkts-array-type-immutable.ets.json | 63 +- .../main/no_tuples_arrays.ets.arkts2.json | 90 --- ...ntity_extended_inheritance.ets.arkts2.json | 10 + 6 files changed, 825 insertions(+), 135 deletions(-) diff --git a/ets2panda/linter/src/lib/TypeScriptLinter.ts b/ets2panda/linter/src/lib/TypeScriptLinter.ts index a15641503f..0242a695d1 100644 --- a/ets2panda/linter/src/lib/TypeScriptLinter.ts +++ b/ets2panda/linter/src/lib/TypeScriptLinter.ts @@ -2176,7 +2176,6 @@ export class TypeScriptLinter extends BaseTypeScriptLinter { this.checkFunctionTypeCompatible(typeNode, tsRhsExpr); this.handleEsObjectAssignment(tsBinaryExpr, typeNode, tsRhsExpr); this.handleSdkGlobalApi(tsBinaryExpr); - this.checkArrayTypeImmutable(tsBinaryExpr); break; case ts.SyntaxKind.AmpersandAmpersandEqualsToken: case ts.SyntaxKind.QuestionQuestionEqualsToken: @@ -2622,44 +2621,6 @@ export class TypeScriptLinter extends BaseTypeScriptLinter { this.handleObjectLiteralAssignment(tsVarDecl); this.handlePropertyDescriptorInScenarios(tsVarDecl); this.handleSdkGlobalApi(tsVarDecl); - this.checkArrayTypeImmutable(tsVarDecl); - } - - private checkArrayTypeImmutable(node: ts.VariableDeclaration | ts.BinaryExpression): void { - if (!this.options.arkts2) { - return; - } - if (ts.isVariableDeclaration(node)) { - if (!node.initializer || ts.isArrayLiteralExpression(node.initializer)) { - return; - } - if (node.type && ts.isArrayTypeNode(node.type)) { - const varDeclType = this.tsTypeChecker.typeToString(this.tsTypeChecker.getTypeAtLocation(node.name)); - const initializerType = this.tsTypeChecker.typeToString(this.tsTypeChecker.getTypeAtLocation(node.initializer)); - if (varDeclType !== initializerType) { - this.incrementCounters(node, FaultID.ArrayTypeImmutable); - } - } - } else { - this.checkArrayTypeImmutableForBinaryExpression(node); - } - } - - private checkArrayTypeImmutableForBinaryExpression(node: ts.BinaryExpression): void { - const sym = this.tsTypeChecker.getSymbolAtLocation(node.left); - const declaration = sym?.declarations?.[0]; - if ( - declaration && - (ts.isVariableDeclaration(declaration) || ts.isParameter(declaration) || ts.isPropertyDeclaration(declaration)) - ) { - if (declaration.type && ts.isArrayTypeNode(declaration.type) && !ts.isArrayLiteralExpression(node.right)) { - const leftType = this.tsTypeChecker.typeToString(this.tsTypeChecker.getTypeAtLocation(node.left)); - const rightType = this.tsTypeChecker.typeToString(this.tsTypeChecker.getTypeAtLocation(node.right)); - if (leftType !== rightType) { - this.incrementCounters(node, FaultID.ArrayTypeImmutable); - } - } - } } private checkTypeFromSdk(type: ts.TypeNode | undefined): void { @@ -5293,6 +5254,7 @@ export class TypeScriptLinter extends BaseTypeScriptLinter { this.handleAsExpressionImport(tsAsExpr); this.handleNoTuplesArrays(node, targetType, exprType); this.handleObjectLiteralAssignmentToClass(tsAsExpr); + this.handleArrayTypeImmutable(tsAsExpr, exprType, targetType); } private isExemptedAsExpression(node: ts.AsExpression): boolean { @@ -6109,6 +6071,7 @@ export class TypeScriptLinter extends BaseTypeScriptLinter { ): void { const rhsType = this.tsTypeChecker.getTypeAtLocation(rhsExpr); this.handleNoTuplesArrays(field, lhsType, rhsType); + this.handleArrayTypeImmutable(field, lhsType, rhsType, rhsExpr); // check that 'sendable typeAlias' is assigned correctly if (this.tsUtils.isWrongSendableFunctionAssignment(lhsType, rhsType)) { this.incrementCounters(field, FaultID.SendableFunctionAssignment); @@ -6665,14 +6628,61 @@ export class TypeScriptLinter extends BaseTypeScriptLinter { } if ( this.tsUtils.isOrDerivedFrom(lhsType, this.tsUtils.isArray) && - this.tsUtils.isOrDerivedFrom(rhsType, TsUtils.isTuple) || + this.tsUtils.isOrDerivedFrom(rhsType, TsUtils.isTuple) || this.tsUtils.isOrDerivedFrom(rhsType, this.tsUtils.isArray) && - this.tsUtils.isOrDerivedFrom(lhsType, TsUtils.isTuple) + this.tsUtils.isOrDerivedFrom(lhsType, TsUtils.isTuple) ) { this.incrementCounters(node, FaultID.NoTuplesArrays); } } + private handleArrayTypeImmutable(node: ts.Node, lhsType: ts.Type, rhsType: ts.Type, rhsExpr?: ts.Expression): void { + if (!this.options.arkts2) { + return; + } + if ( + !(this.tsUtils.isOrDerivedFrom(lhsType, this.tsUtils.isArray) && + this.tsUtils.isOrDerivedFrom(rhsType, this.tsUtils.isArray) && + lhsType !== rhsType) + ) { + return; + } + + const rhsTypeStr = this.tsTypeChecker.typeToString(rhsType); + let lhsTypeStr = this.tsTypeChecker.typeToString(lhsType); + if (rhsExpr && (this.isNullOrEmptyArray(rhsExpr) || ts.isArrayLiteralExpression(rhsExpr))) { + return; + } + + if (ts.isAsExpression(node) && ts.isArrayLiteralExpression(node.expression)) { + node.expression.elements.forEach((elem) => { + if (elem.kind === ts.SyntaxKind.FalseKeyword || elem.kind === ts.SyntaxKind.TrueKeyword) { + lhsTypeStr = rhsTypeStr.replace(elem.getText(), 'boolean'); + } + }); + } + if (lhsTypeStr !== rhsTypeStr) { + this.incrementCounters(node, FaultID.ArrayTypeImmutable); + } + } + + private isNullOrEmptyArray(expr: ts.Expression): boolean { + if (ts.isNewExpression(expr)) { + const constructorSym = this.tsTypeChecker.getSymbolAtLocation(expr.expression); + if (constructorSym?.name === 'Array') { + if (!expr.arguments || expr.arguments.length === 0) { + return true; + } + if (expr.arguments.length === 1) { + const argType = this.tsTypeChecker.getTypeAtLocation(expr.arguments[0]); + return !!(argType.flags & ts.TypeFlags.NumberLike); + } + } + } + + return false; + } + private handleExponentOperation(node: ts.Node): void { if (!this.options.arkts2) { return; @@ -9039,10 +9049,10 @@ export class TypeScriptLinter extends BaseTypeScriptLinter { private shouldIncrementCounters(node: ts.ElementAccessExpression): boolean { const indexExpr = node.argumentExpression; if (!indexExpr) { - return false; + return false; } if (ts.isStringLiteral(indexExpr) || ts.isNumericLiteral(indexExpr)) { - return true; + return true; } const type = this.tsTypeChecker.getTypeAtLocation(indexExpr); const typeString = this.tsTypeChecker.typeToString(type); diff --git a/ets2panda/linter/test/main/arkts-array-type-immutable.ets b/ets2panda/linter/test/main/arkts-array-type-immutable.ets index 75a02116dd..c0d79ba065 100644 --- a/ets2panda/linter/test/main/arkts-array-type-immutable.ets +++ b/ets2panda/linter/test/main/arkts-array-type-immutable.ets @@ -34,4 +34,123 @@ let a3: (number | string)[] = new Array(1, 2); // error function test(a: number[]): void { let b: (number | string)[] = [1]; b = a; // error -} \ No newline at end of file +} + +let arrayTypeImmutableA2: [number] = [1]; +let arrayTypeImmutableB2: [number | string] = arrayTypeImmutableA2; + +class ArrayTypeImmutableA{ + arrayTypeImmutableA: number[] = [1]; + arrayTypeImmutableB: (number | string)[] = this.arrayTypeImmutableA; // error + arrayTypeImmutableB1: (number | string)[] = this.arrayTypeImmutableA; // error + + arrayTypeImmutableA2: [number] = [1]; + arrayTypeImmutableB2: [number | string] = arrayTypeImmutableA2; + arrayTypeImmutableB21: [number | string] = this.arrayTypeImmutableA2; +} + +interface IA { + ia: string; +} + +type TA = string | IA + +interface IB { + i: TA|TA[] +} + +class CA { + static fun(...a: IB[]): void{}; +} + +CA.fun({ + i: [ { ia: '1'}, { ia: '2'}, { ia: '3'}, ] as IA[] // error +} as IB) + + +class A { + a: number[] = [-11,0]; + arrayData: (number| string| boolean)[] = [1, 'hi'] + arrs: (number| boolean)[] = new A().a //error + val: (number|string|boolean) [] = new A().arrayData + A() { + const val1 = new A().a + let array2: (string | number | boolean)[] = val1 //error + } + aa(ss:(number| boolean)[]) { + ss = this.a //error + } + cc(): (boolean| number)[] { + return [true, 33]; + } + dd(): (boolean| string| A)[] { + return [true, 'hello', new A()]; + } + ee() { + let ccVal: (boolean | number | boolean)[] = this.cc() + return ccVal; + } + + ff() { + let array: (number| boolean|string)[] = newArr; //error + return array; + } + gg() { + return this.arrs; + } +} + +function test2():(string|number|boolean)[] { + return ['s', 3.14, true]; +} +function test3() { + let obj: A = new A() + return obj.dd(); +} + +let objA: A = new A() + +const newArr: (number| boolean)[] = [1, true] +const newArr1: (number|string|boolean)[] = [1, '3.14', true] +const array: (number | boolean|string)[] = newArr1 +const newArr2: (string|number|boolean)[] = ['s', 3.14, false] +const array1: (number | string | boolean)[] = newArr2 +const array2: (string | number | boolean)[] = newArr1 + +let tt: (boolean | number | boolean)[] = this.test2() //error +let gg: (boolean | number | boolean)[] = new A().ee() +let ff = new A().ff() +let hh: (boolean | number | string)[] =ff +let mm: (boolean | number | boolean)[] = objA.gg(); +let test: (boolean | A | string)[] = test3() + +let array13: (number|boolean|string)[] = newArr as (number|string)[] //error +let array14: (number|boolean|number)[] = [3.14, true] as (number|boolean)[] +let array15: (boolean|number)[] = array as (number|boolean)[] //error +let array16: (boolean | number | boolean)[] = objA.gg() as (boolean | number)[] +let tuple15: (number|boolean|string)[] = this.test2() as (string|number|boolean)[] +let tuple16: (number|boolean)[] = array as [number, number, boolean] +let array17: (number|string|boolean)[] = ['s', 3.14, true] as (number|string|boolean)[] +const array18 = Array.from({ length: 5 }, (_, index) => index % 2 === 0 ? index : index % 3 === 0); +let array19: (number|boolean)[] = array18 as (number)[] //error +const originalArray: number[] = [1, 2, 3, 4, 5]; +const array20 = originalArray.map((value) => value % 2 === 0 ? true : value * 2); +let array21: [number, boolean] = array20 as [number, boolean] +let array22: (number|string)[] = array20 as (number)[] //error +const array23: (number)[] = [1, 2, 3, 4, 5]; + +let aaa: number[] = [1] +let bbb: (number | string)[] = aaa //error +const fn29: Function[] = []; +function bar(): T[] { + return []; +} +let a: number[] = []; +let repairableArr: Array = new Array(); +repairableArr = new Array(3); +Reflect.apply(() => {}, objA, []); +if (handler.apply) handler.apply(objA, objA, []); + +let readonlyArr: ReadonlyArray = []; +let arr66 = new Array(); +readonlyArr = arr66; //error \ No newline at end of file diff --git a/ets2panda/linter/test/main/arkts-array-type-immutable.ets.arkts2.json b/ets2panda/linter/test/main/arkts-array-type-immutable.ets.arkts2.json index 50fb25efbd..fa6b50ae6c 100644 --- a/ets2panda/linter/test/main/arkts-array-type-immutable.ets.arkts2.json +++ b/ets2panda/linter/test/main/arkts-array-type-immutable.ets.arkts2.json @@ -123,6 +123,586 @@ "suggest": "", "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", "severity": "ERROR" + }, + { + "line": 39, + "column": 39, + "endLine": 39, + "endColumn": 40, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 43, + "column": 36, + "endLine": 43, + "endColumn": 37, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 44, + "column": 3, + "endLine": 44, + "endColumn": 71, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 45, + "column": 3, + "endLine": 45, + "endColumn": 72, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 47, + "column": 37, + "endLine": 47, + "endColumn": 38, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 67, + "column": 6, + "endLine": 67, + "endColumn": 63, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 72, + "column": 19, + "endLine": 72, + "endColumn": 21, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 72, + "column": 22, + "endLine": 72, + "endColumn": 23, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 73, + "column": 45, + "endLine": 73, + "endColumn": 46, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 74, + "column": 3, + "endLine": 74, + "endColumn": 40, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 78, + "column": 9, + "endLine": 78, + "endColumn": 53, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 81, + "column": 5, + "endLine": 81, + "endColumn": 16, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 84, + "column": 19, + "endLine": 84, + "endColumn": 21, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 95, + "column": 9, + "endLine": 95, + "endColumn": 51, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 106, + "column": 10, + "endLine": 106, + "endColumn": 15, + "problem": "LimitedReturnTypeInference", + "suggest": "", + "rule": "Function return type inference is limited (arkts-no-implicit-return-types)", + "severity": "ERROR" + }, + { + "line": 113, + "column": 38, + "endLine": 113, + "endColumn": 39, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 114, + "column": 45, + "endLine": 114, + "endColumn": 46, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 120, + "column": 5, + "endLine": 120, + "endColumn": 54, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 122, + "column": 5, + "endLine": 122, + "endColumn": 22, + "problem": "AnyType", + "suggest": "", + "rule": "Use explicit types instead of \"any\", \"unknown\" (arkts-no-any-unknown)", + "severity": "ERROR" + }, + { + "line": 127, + "column": 5, + "endLine": 127, + "endColumn": 69, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 127, + "column": 42, + "endLine": 127, + "endColumn": 69, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 129, + "column": 35, + "endLine": 129, + "endColumn": 62, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 132, + "column": 5, + "endLine": 132, + "endColumn": 70, + "problem": "NoTuplesArrays", + "suggest": "", + "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", + "severity": "ERROR" + }, + { + "line": 132, + "column": 36, + "endLine": 132, + "endColumn": 70, + "problem": "NoTuplesArrays", + "suggest": "", + "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 17, + "endLine": 134, + "endColumn": 99, + "problem": "GenericCallNoTypeArgs", + "suggest": "", + "rule": "Type inference in case of generic function calls is limited (arkts-no-inferred-generic-params)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 38, + "endLine": 134, + "endColumn": 39, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 44, + "endLine": 134, + "endColumn": 45, + "problem": "UnknownType", + "suggest": "", + "rule": "Use explicit types instead of \"any\", \"unknown\" (arkts-no-any-unknown)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 65, + "endLine": 134, + "endColumn": 66, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 71, + "endLine": 134, + "endColumn": 72, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 91, + "endLine": 134, + "endColumn": 92, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 97, + "endLine": 134, + "endColumn": 98, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 135, + "column": 5, + "endLine": 135, + "endColumn": 56, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 135, + "column": 35, + "endLine": 135, + "endColumn": 56, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 136, + "column": 34, + "endLine": 136, + "endColumn": 35, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 136, + "column": 37, + "endLine": 136, + "endColumn": 38, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 136, + "column": 40, + "endLine": 136, + "endColumn": 41, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 136, + "column": 43, + "endLine": 136, + "endColumn": 44, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 136, + "column": 46, + "endLine": 136, + "endColumn": 47, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 137, + "column": 54, + "endLine": 137, + "endColumn": 55, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 137, + "column": 60, + "endLine": 137, + "endColumn": 61, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 137, + "column": 79, + "endLine": 137, + "endColumn": 80, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 138, + "column": 34, + "endLine": 138, + "endColumn": 62, + "problem": "NoTuplesArrays", + "suggest": "", + "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", + "severity": "ERROR" + }, + { + "line": 139, + "column": 5, + "endLine": 139, + "endColumn": 55, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 139, + "column": 34, + "endLine": 139, + "endColumn": 55, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 140, + "column": 30, + "endLine": 140, + "endColumn": 31, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 140, + "column": 33, + "endLine": 140, + "endColumn": 34, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 140, + "column": 36, + "endLine": 140, + "endColumn": 37, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 140, + "column": 39, + "endLine": 140, + "endColumn": 40, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 140, + "column": 42, + "endLine": 140, + "endColumn": 43, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 142, + "column": 22, + "endLine": 142, + "endColumn": 23, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 143, + "column": 5, + "endLine": 143, + "endColumn": 35, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, + { + "line": 149, + "column": 36, + "endLine": 149, + "endColumn": 47, + "problem": "GenericCallNoTypeArgs", + "suggest": "", + "rule": "Type inference in case of generic function calls is limited (arkts-no-inferred-generic-params)", + "severity": "ERROR" + }, + { + "line": 150, + "column": 17, + "endLine": 150, + "endColumn": 29, + "problem": "GenericCallNoTypeArgs", + "suggest": "", + "rule": "Type inference in case of generic function calls is limited (arkts-no-inferred-generic-params)", + "severity": "ERROR" + }, + { + "line": 150, + "column": 27, + "endLine": 150, + "endColumn": 28, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 151, + "column": 1, + "endLine": 151, + "endColumn": 54, + "problem": "InteropCallReflect", + "suggest": "", + "rule": "Reflect API usage is not allowed in interop calls when an \"Object\" parameter receives a class instance (arkts-interop-d2s-static-reflect-on-dynamic-instance)", + "severity": "ERROR" + }, + { + "line": 151, + "column": 9, + "endLine": 151, + "endColumn": 14, + "problem": "LimitedStdLibApi", + "suggest": "", + "rule": "Usage of standard library is restricted (arkts-limited-stdlib)", + "severity": "ERROR" + }, + { + "line": 155, + "column": 5, + "endLine": 155, + "endColumn": 32, + "problem": "NumericSemantics", + "suggest": "", + "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", + "severity": "ERROR" + }, + { + "line": 156, + "column": 1, + "endLine": 156, + "endColumn": 20, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" } ] } \ No newline at end of file diff --git a/ets2panda/linter/test/main/arkts-array-type-immutable.ets.json b/ets2panda/linter/test/main/arkts-array-type-immutable.ets.json index ca88f857e9..d8f6775c62 100644 --- a/ets2panda/linter/test/main/arkts-array-type-immutable.ets.json +++ b/ets2panda/linter/test/main/arkts-array-type-immutable.ets.json @@ -13,5 +13,66 @@ "See the License for the specific language governing permissions and", "limitations under the License." ], - "result": [] + "result": [ + { + "line": 106, + "column": 10, + "endLine": 106, + "endColumn": 15, + "problem": "LimitedReturnTypeInference", + "suggest": "", + "rule": "Function return type inference is limited (arkts-no-implicit-return-types)", + "severity": "ERROR" + }, + { + "line": 122, + "column": 5, + "endLine": 122, + "endColumn": 22, + "problem": "AnyType", + "suggest": "", + "rule": "Use explicit types instead of \"any\", \"unknown\" (arkts-no-any-unknown)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 17, + "endLine": 134, + "endColumn": 99, + "problem": "GenericCallNoTypeArgs", + "suggest": "", + "rule": "Type inference in case of generic function calls is limited (arkts-no-inferred-generic-params)", + "severity": "ERROR" + }, + { + "line": 134, + "column": 44, + "endLine": 134, + "endColumn": 45, + "problem": "UnknownType", + "suggest": "", + "rule": "Use explicit types instead of \"any\", \"unknown\" (arkts-no-any-unknown)", + "severity": "ERROR" + }, + { + "line": 151, + "column": 1, + "endLine": 151, + "endColumn": 53, + "problem": "LimitedStdLibApi", + "suggest": "", + "rule": "Usage of standard library is restricted (arkts-limited-stdlib)", + "severity": "ERROR" + }, + { + "line": 151, + "column": 1, + "endLine": 151, + "endColumn": 54, + "problem": "InteropCallReflect", + "suggest": "", + "rule": "Reflect API usage is not allowed in interop calls when an \"Object\" parameter receives a class instance (arkts-interop-d2s-static-reflect-on-dynamic-instance)", + "severity": "ERROR" + } + ] } \ No newline at end of file diff --git a/ets2panda/linter/test/main/no_tuples_arrays.ets.arkts2.json b/ets2panda/linter/test/main/no_tuples_arrays.ets.arkts2.json index a3ca4dc49b..9af978fcfc 100644 --- a/ets2panda/linter/test/main/no_tuples_arrays.ets.arkts2.json +++ b/ets2panda/linter/test/main/no_tuples_arrays.ets.arkts2.json @@ -64,16 +64,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 25, - "column": 13, - "endLine": 25, - "endColumn": 59, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 29, "column": 30, @@ -124,16 +114,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 39, - "column": 13, - "endLine": 39, - "endColumn": 62, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 63, "column": 43, @@ -164,16 +144,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 65, - "column": 7, - "endLine": 65, - "endColumn": 42, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 67, "column": 7, @@ -184,16 +154,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 67, - "column": 7, - "endLine": 67, - "endColumn": 53, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 68, "column": 7, @@ -204,16 +164,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 68, - "column": 7, - "endLine": 68, - "endColumn": 53, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 70, "column": 5, @@ -224,16 +174,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 70, - "column": 5, - "endLine": 70, - "endColumn": 53, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 73, "column": 5, @@ -244,16 +184,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 73, - "column": 5, - "endLine": 73, - "endColumn": 43, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 74, "column": 5, @@ -264,16 +194,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 74, - "column": 5, - "endLine": 74, - "endColumn": 48, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 75, "column": 5, @@ -284,16 +204,6 @@ "rule": "Array and tuple are different type(arkts-no-tuples-arrays)", "severity": "ERROR" }, - { - "line": 75, - "column": 5, - "endLine": 75, - "endColumn": 50, - "problem": "ArrayTypeImmutable", - "suggest": "", - "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", - "severity": "ERROR" - }, { "line": 78, "column": 35, diff --git a/ets2panda/linter/test/main/structural_identity_extended_inheritance.ets.arkts2.json b/ets2panda/linter/test/main/structural_identity_extended_inheritance.ets.arkts2.json index d99589819b..72f2d82336 100644 --- a/ets2panda/linter/test/main/structural_identity_extended_inheritance.ets.arkts2.json +++ b/ets2panda/linter/test/main/structural_identity_extended_inheritance.ets.arkts2.json @@ -164,6 +164,16 @@ "rule": "Numeric semantics is different for integer values (arkts-numeric-semantic)", "severity": "ERROR" }, + { + "line": 56, + "column": 1, + "endLine": 56, + "endColumn": 18, + "problem": "ArrayTypeImmutable", + "suggest": "", + "rule": "Array type is immutable in ArkTS1.2 (arkts-array-type-immutable)", + "severity": "ERROR" + }, { "line": 73, "column": 1, -- Gitee