diff --git a/migrator/config/java-api-mapper.xml b/migrator/config/java-api-mapper.xml index ed623b6419a8f3b9064d3a2ca8e0c7703815a424..964748e077f4292c996b4c9d603b053da54a6102 100644 --- a/migrator/config/java-api-mapper.xml +++ b/migrator/config/java-api-mapper.xml @@ -55,7 +55,7 @@ - + @@ -65,7 +65,7 @@ - + @@ -199,7 +199,7 @@ --> - + @@ -209,7 +209,7 @@ - + @@ -225,7 +225,7 @@ --> - + @@ -243,7 +243,7 @@ --> - + @@ -258,20 +258,37 @@ - + + + + + + + + + + + + + + + - @@ -283,7 +300,7 @@ --> - + @@ -293,7 +310,7 @@ - + @@ -303,57 +320,169 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + - + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - - - - - - - - - + + + + + + + + + + + @@ -366,7 +495,7 @@ --> - + @@ -376,7 +505,7 @@ - + @@ -394,7 +523,7 @@ --> - + @@ -404,7 +533,7 @@ - + @@ -420,7 +549,7 @@ --> - + @@ -439,7 +568,7 @@ --> - + @@ -460,7 +589,7 @@ --> - + @@ -470,7 +599,7 @@ - + @@ -486,7 +615,7 @@ --> - + @@ -505,7 +634,7 @@ --> - + @@ -526,7 +655,7 @@ --> - + @@ -536,7 +665,7 @@ - + @@ -552,7 +681,7 @@ --> - + @@ -571,7 +700,7 @@ --> - + @@ -592,7 +721,7 @@ --> - + @@ -602,7 +731,7 @@ - + @@ -618,7 +747,7 @@ --> - + @@ -637,7 +766,7 @@ --> - + @@ -650,7 +779,7 @@ - + + - + - - - - - - - + + + + + + + + + + + + + + + + + + + + @@ -736,20 +875,29 @@ --> + + + + + + + + - + - + - + @@ -758,48 +906,41 @@ - - - - - + + + + + + + + + + + + + + + - - + + + + + + - - - - - - - + + + + + - - - - - - - - diff --git a/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx b/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx index 546e10db26560dce2b175475fd9fb67838fe1cc6..792dbc5959dbc45c10b9692309c6b4e847c7e4bf 100644 Binary files a/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx and b/migrator/docs/Java_API_to_ArkTS_API_mapping_rules.docx differ diff --git a/migrator/docs/java-api-list.xml b/migrator/docs/java-api-list.xml index 4ffec05bcd3b170396dc7b8db123a53083bb17fb..ce3cb0dd184ec72f28be9b7603c06d8b2eb19981 100644 --- a/migrator/docs/java-api-list.xml +++ b/migrator/docs/java-api-list.xml @@ -93,7 +93,7 @@ // Interfaces: java.lang.Appendable java.lang.AutoCloseable - java.lang.CharSequence + java.lang.CharSequence ==> std.core.String ???? java.lang.Cloneable ==> std.core.Comparable @@ -149,7 +149,7 @@ boolean equals(Object obj) ArkTS: the same float floatValue() ArkTS: the same int hashCode() ArkTS: the same - static int hashCode(byte value) + static int hashCode(byte value) ArkTS: new Byte(value).hasCode() int intValue() ArkTS: the same long longValue() ArkTS: the same static byte parseByte(String s) @@ -233,7 +233,7 @@ static byte UNASSIGNED static byte UPPERCASE_LETTER - Character(char value) ArkTS: the same + Character(char value) ArkTS: Char(char value) static int charCount(int codePoint) char charValue() static int codePointAt(char[] a, int index) @@ -258,15 +258,15 @@ static int getType(char ch) static int getType(int codePoint) int hashCode() ArkTS: the same - static int hashCode(char value) ArkTS: the same - static char highSurrogate(int codePoint) ArkTS: static getHighSurrogate(value: int): char + static int hashCode(char value) ArkTS: the same function name but the type is renamed + static char highSurrogate(int codePoint) ArkTS: static getHighSurrogate(codePoint: int): char static boolean isAlphabetic(int codePoint) static boolean isBmpCodePoint(int codePoint) static boolean isDefined(char ch) static boolean isDefined(int codePoint) - static boolean isDigit(char ch) ArkTS: static isDecDigit(value: char): boolean + static boolean isDigit(char ch) ArkTS: the same function name but the type is renamed static boolean isDigit(int codePoint) - static boolean isHighSurrogate(char ch) ArkTS: the same + static boolean isHighSurrogate(char ch) ArkTS: the same function name but the type is renamed static boolean isIdentifierIgnorable(char ch) static boolean isIdentifierIgnorable(int codePoint) static boolean isIdeographic(int codePoint) @@ -278,13 +278,13 @@ static boolean isJavaIdentifierStart(int codePoint) static boolean isJavaLetter(char ch) static boolean isJavaLetterOrDigit(char ch) - static boolean isLetter(char ch) - static boolean isLetter(int codePoint) ArkTS: the same + static boolean isLetter(char ch) ArkTS: the same function but the type is renamed + static boolean isLetter(int codePoint) static boolean isLetterOrDigit(char ch) static boolean isLetterOrDigit(int codePoint) - static boolean isLowerCase(char ch) ArkTS: the same + static boolean isLowerCase(char ch) ArkTS: the same function but the type is renamed static boolean isLowerCase(int codePoint) - static boolean isLowSurrogate(char ch) ArkTS: the same + static boolean isLowSurrogate(char ch) ArkTS: the same function but the type is renamed static boolean isMirrored(char ch) static boolean isMirrored(int codePoint) static boolean isSpace(char ch) @@ -299,27 +299,27 @@ static boolean isUnicodeIdentifierPart(int codePoint) static boolean isUnicodeIdentifierStart(char ch) static boolean isUnicodeIdentifierStart(int codePoint) - static boolean isUpperCase(char ch) ArkTS: the same + static boolean isUpperCase(char ch) ArkTS: the same function but the type is renamed static boolean isUpperCase(int codePoint) static boolean isValidCodePoint(int codePoint) - static boolean isWhitespace(char ch) ArkTS: the same + static boolean isWhitespace(char ch) ArkTS: the same function but the type is renamed static boolean isWhitespace(int codePoint) - static char lowSurrogate(int codePoint) ArkTS: static getLowSurrogate(value: int): char + static char lowSurrogate(int codePoint) ArkTS: static getLowSurrogate(codePoint: int): char static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset) static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset) static char reverseBytes(char ch) static char[] toChars(int codePoint) static int toChars(int codePoint, char[] dst, int dstIndex) static int toCodePoint(char high, char low) - static char toLowerCase(char ch) ArkTS: the same + static char toLowerCase(char ch) ArkTS: the same function but the type is renamed static int toLowerCase(int codePoint) - String toString() - static String toString(char c) + String toString() ArkTS: the same + static String toString(char c) ArkTS: new Char(c).toString(); static char toTitleCase(char ch) static int toTitleCase(int codePoint) - static char toUpperCase(char ch) ArkTS: the same + static char toUpperCase(char ch) ArkTS: the same function but the type is renamed static int toUpperCase(int codePoint) - static Character valueOf(char c) ArkTS: the same + static Character valueOf(char c) ArkTS: the same function but the type is renamed java.lang.Character.Subset java.lang.Character.UnicodeBlock diff --git a/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java b/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java index a582394c7e940d9bc169b02375fc6e0713d3718b..ed9f1b7851194112c08eaf0a18f40339dec9162f 100644 --- a/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java +++ b/migrator/src/com/ohos/migrator/apimapper/ArrayLiteralExpression.java @@ -109,6 +109,7 @@ public class ArrayLiteralExpression extends ArrayList { public SingleExpressionContext buildArktsNode(List arktsOrigArguments) { SingleExpressionContext arktsArrayLiteralExprParent = new SingleExpressionContext(); ArrayLiteralExpressionContext arktsArrayLiteralExpr = new ArrayLiteralExpressionContext(arktsArrayLiteralExprParent); + arktsArrayLiteralExprParent.addChild(arktsArrayLiteralExpr).setParent(arktsArrayLiteralExprParent); ExpressionSequenceContext arktsExprSequence = new ExpressionSequenceContext(arktsArrayLiteralExpr, 0); diff --git a/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java b/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java index 8b5c00736c1344798e96420b58178504fe04775a..5156a6b8636aa185b6fa26c7d00763c17127334c 100644 --- a/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java +++ b/migrator/src/com/ohos/migrator/apimapper/BinaryExpression.java @@ -358,6 +358,8 @@ public class BinaryExpression { arktsBinExpr.addChild(buildArktsOperandNode(operand2, arktsOrigArguments)).setParent(arktsBinExpr); assert (arktsBinExpr != null); + arktsBinExprParent.addChild(arktsBinExpr).setParent(arktsBinExprParent); + return arktsBinExprParent; } } diff --git a/migrator/src/com/ohos/migrator/apimapper/CastExpression.java b/migrator/src/com/ohos/migrator/apimapper/CastExpression.java index 9a7026d7342ca54885330144977b1454a1ca7a9e..d495154f274533852c603582667dd408292d36fa 100644 --- a/migrator/src/com/ohos/migrator/apimapper/CastExpression.java +++ b/migrator/src/com/ohos/migrator/apimapper/CastExpression.java @@ -57,7 +57,7 @@ public class CastExpression { castExpression.index = Integer.valueOf(getAttribute(startElement, indexAttr)); } else if (PrimaryType.tag.equals(tag)) { - castExpression.primaryType = PrimaryType.read(xmlReader, xmlEvent); + castExpression.primaryType = PrimaryType.read(xmlReader); } else if (IntersectionType.tag.equals(tag)) { castExpression.intersectionType = IntersectionType.read(xmlReader, xmlEvent); @@ -87,8 +87,10 @@ public class CastExpression { SingleExpressionContext arktsCastExprParent = new SingleExpressionContext(); CastExpressionContext arktsCastExpr = new CastExpressionContext(arktsCastExprParent); + arktsCastExprParent.addChild(arktsCastExpr).setParent(arktsCastExprParent); - arktsCastExpr.children.add(arktsOrigArguments.get(index)); + //arktsCastExpr.children.add(arktsOrigArguments.get(index)); + arktsCastExpr.addChild(arktsOrigArguments.get(index)); arktsCastExpr.addChild(NodeBuilder.terminalNode(StaticTSParser.As)); if (primaryType != null ) { diff --git a/migrator/src/com/ohos/migrator/apimapper/Literal.java b/migrator/src/com/ohos/migrator/apimapper/Literal.java index 60598a70e5ac2303f8e1d547682c8b3532ccfe0b..8b1309eb28b4b839509d67f2b92eec1a576d28a6 100644 --- a/migrator/src/com/ohos/migrator/apimapper/Literal.java +++ b/migrator/src/com/ohos/migrator/apimapper/Literal.java @@ -18,7 +18,7 @@ package com.ohos.migrator.apimapper; // import com.ohos.migrator.java.NodeBuilder; -import com.ohos.migrator.staticTS.parser.StaticTSParser; +import com.ohos.migrator.staticTS.parser.StaticTSParser.SingleExpressionContext; import static com.ohos.migrator.apimapper.Util.*; @@ -89,7 +89,7 @@ public class Literal { return literal; } - public StaticTSParser.SingleExpressionContext buildArktsNode() { + public SingleExpressionContext buildArktsNode() { switch (type) { case NULL: return NodeBuilder.nullLiteral(); case BOOLEAN: return NodeBuilder.boolLiteral(Boolean.parseBoolean(value)); diff --git a/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java b/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java index 2bb839215d6d6004b22389f46e1d2b46736835d3..b56e79e622c97e4c57966d4880100758b7668404 100644 --- a/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java +++ b/migrator/src/com/ohos/migrator/apimapper/PrimaryType.java @@ -35,7 +35,7 @@ public class PrimaryType { private TypeReference typeReference = null; private ArrayType arrayType = null; - static PrimaryType read(XMLEventReader xmlReader, XMLEvent xmlPrimaryTypeEveent) throws XMLStreamException { + static PrimaryType read(XMLEventReader xmlReader) throws XMLStreamException { PrimaryType primaryType = new PrimaryType(); while (xmlReader.hasNext()) { @@ -46,7 +46,7 @@ public class PrimaryType { String tag = startElement.getName().getLocalPart(); if (tagPredefinedType.equals(tag)) { - primaryType.predefinedType = Util.getAttribute(startElement, Util.nameAttr); + primaryType.predefinedType = getAttribute(startElement, nameAttr); } else if (TypeReference.tag.equals(tag)) { primaryType.typeReference = TypeReference.read(xmlReader, xmlEvent); @@ -75,7 +75,7 @@ public class PrimaryType { public PrimaryTypeContext buildArktsNode() { PrimaryTypeContext arktsPrimaryType = new PrimaryTypeContext(null, 0); - if (!Util.isStringEmpty(predefinedType)) { + if (!isStringEmpty(predefinedType)) { arktsPrimaryType.addChild(NodeBuilder.predefinedType(predefinedType)).setParent(arktsPrimaryType); } else if (typeReference != null) { diff --git a/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java b/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java index 95c01de4579848901bdd5908c5da01d87e7be909..d688c6310b2a2f11e2e2841eaab618e1a257b92b 100644 --- a/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java +++ b/migrator/src/com/ohos/migrator/apimapper/TernaryExpression.java @@ -166,12 +166,14 @@ public class TernaryExpression { } public SingleExpressionContext buildArktsNode(List arktsOrigArguments) { SingleExpressionContext arktsTernaryExprParent = new SingleExpressionContext(); - TernaryExpressionContext arktsTernaryExpr =new TernaryExpressionContext(arktsTernaryExprParent); + TernaryExpressionContext arktsTernaryExpr = new TernaryExpressionContext(arktsTernaryExprParent); arktsTernaryExpr.addChild(buildOperandArktsNode(operand1, arktsOrigArguments)).setParent(arktsTernaryExpr); arktsTernaryExpr.addChild(buildOperandArktsNode(operand2, arktsOrigArguments)).setParent(arktsTernaryExpr); arktsTernaryExpr.addChild(buildOperandArktsNode(operand3, arktsOrigArguments)).setParent(arktsTernaryExpr); + arktsTernaryExprParent.addChild(arktsTernaryExpr).setParent(arktsTernaryExprParent); + return arktsTernaryExprParent; } } diff --git a/migrator/src/com/ohos/migrator/apimapper/TypeReference.java b/migrator/src/com/ohos/migrator/apimapper/TypeReference.java index 7c96ecfece81a3fd227ac2d2a61b47e8c00bfcec..05f59cb1fcfa4c00f1232adced30505dd206f10f 100644 --- a/migrator/src/com/ohos/migrator/apimapper/TypeReference.java +++ b/migrator/src/com/ohos/migrator/apimapper/TypeReference.java @@ -18,6 +18,7 @@ package com.ohos.migrator.apimapper; import com.ohos.migrator.java.NodeBuilder; import com.ohos.migrator.staticTS.parser.StaticTSParser.TypeReferenceContext; import com.ohos.migrator.staticTS.parser.StaticTSParser.TypeArgumentContext; +import static com.ohos.migrator.apimapper.Util.*; import javax.xml.stream.XMLEventReader; import javax.xml.stream.XMLStreamException; @@ -35,11 +36,11 @@ import java.util.List; // public class TypeReference { static public String tag = "TypeReference"; - private String arktsName = null; + private String arktsTypeName = null; private TypeArguments typeArguments = null; public String getArktsName() { - return arktsName; + return arktsTypeName; } static public TypeReference read(XMLEventReader xmlReader, XMLEvent xmlTypeReferenceEvent) throws XMLStreamException { @@ -47,7 +48,7 @@ public class TypeReference { assert xmlTypeReferenceEvent.isStartElement(); StartElement startElement = xmlTypeReferenceEvent.asStartElement(); - typeReference.arktsName = Util.getAttribute(startElement, Util.arktsNameAttr); + typeReference.arktsTypeName = getAttribute(startElement, arktsTypeNameAttr); while (xmlReader.hasNext()) { XMLEvent xmlEvent = xmlReader.nextEvent(); @@ -79,7 +80,7 @@ public class TypeReference { } public TypeReferenceContext buildArktsNode(List arktsOrigTypeArguments) { - TypeReferenceContext arktsTypeReference = NodeBuilder.typeReference(arktsName); + TypeReferenceContext arktsTypeReference = NodeBuilder.typeReference(arktsTypeName); if (typeArguments != null) { arktsTypeReference.addChild(typeArguments.buildArktsNode(arktsOrigTypeArguments)).setParent(arktsTypeReference); diff --git a/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java b/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java index 074e4fefd18910d80fbd9f672d974a0cd299fd8d..cc2fd617efc600b1c9c1202d2f0c88fe93411400 100644 --- a/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java +++ b/migrator/src/com/ohos/migrator/apimapper/UnaryExpression.java @@ -115,7 +115,9 @@ public class UnaryExpression { arktsUnaryExpr.addChild(NodeBuilder.terminalNode(arktsOpType)); - arktsUnaryExpr.addChild((RuleContext)arktsOrigArguments.get(index)); + arktsUnaryExpr.addChild(arktsOrigArguments.get(index)); + + arktsUnaryExprParent.addChild(arktsUnaryExpr).setParent(arktsUnaryExprParent); return arktsUnaryExprParent; } diff --git a/migrator/src/com/ohos/migrator/apimapper/Util.java b/migrator/src/com/ohos/migrator/apimapper/Util.java index 60fa7be25c86be86b76efb9b58005be5cca08401..e266d757c0339f742f14c816367c70f9f79b7451 100644 --- a/migrator/src/com/ohos/migrator/apimapper/Util.java +++ b/migrator/src/com/ohos/migrator/apimapper/Util.java @@ -36,6 +36,7 @@ public class Util { static public QName javaMethodArgsAttr = new QName("javaMethodArgs"); static public QName javaImportAttr = new QName("javaImport"); static public QName arktsNameAttr = new QName("arktsName"); + static public QName arktsTypeNameAttr = new QName("arktsTypeName"); static public QName arktsItemAttr = new QName("arktsItem"); static public QName arktsAliasAttr = new QName("arktsAlias"); static public QName arktsFromAttr = new QName("arktsFrom"); diff --git a/migrator/src/com/ohos/migrator/java/JavaApiMapper.java b/migrator/src/com/ohos/migrator/java/JavaApiMapper.java index 6d2611444297913eff34c111e55f52d5a94140a5..99bbdd7718cd7636dc39f4374dc4ef42149d1ef3 100644 --- a/migrator/src/com/ohos/migrator/java/JavaApiMapper.java +++ b/migrator/src/com/ohos/migrator/java/JavaApiMapper.java @@ -241,10 +241,8 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor { private void substituteObject(CallExpressionContext arktsCallExpression, List arktsOrigArguments) { SingleExpressionContext arktsMethodExpression = arktsCallExpression.singleExpression(); - assert (arktsMethodExpression instanceof SingleExpressionContext); - ParseTree arktsChildNode = arktsMethodExpression.getChild(0); - assert (arktsChildNode instanceof MemberAccessExpressionContext); - MemberAccessExpressionContext arktsMemberAccessExpr = (MemberAccessExpressionContext)arktsChildNode; + assert (arktsMethodExpression.getChild(0) instanceof MemberAccessExpressionContext); + MemberAccessExpressionContext arktsMemberAccessExpr = (MemberAccessExpressionContext)arktsMethodExpression.getChild(0); SingleExpressionContext arktsOrigObject = arktsMemberAccessExpr.singleExpression(); SingleExpressionContext arktsNewObject = null; @@ -267,6 +265,19 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor { } } + private void substituteType(CallExpressionContext arktsCallExpression) { + SingleExpressionContext arktsMethodExpression = arktsCallExpression.singleExpression(); + assert (arktsMethodExpression.getChild(0) instanceof MemberAccessExpressionContext); + MemberAccessExpressionContext arktsMemberAccessExpr = (MemberAccessExpressionContext)arktsMethodExpression.getChild(0); + + SingleExpressionContext arktsIdentifier = arktsMemberAccessExpr.singleExpression(); + assert (arktsIdentifier.getChildCount() == 1 && arktsIdentifier.getChild(0) instanceof IdentifierExpressionContext); + IdentifierExpressionContext arktsIdentifierExpr = (IdentifierExpressionContext)arktsIdentifier.getChild(0); + assert (arktsIdentifierExpr.getChildCount() == 1); + arktsIdentifierExpr.children.clear(); + arktsIdentifierExpr.addChild(new TerminalNodeImpl(new CommonToken(StaticTSParser.Identifier, arktsTypeName))); + } + private List getOrigArgs(CallExpressionContext arktsCallExpression) { ArgumentsContext arktsArguments = arktsCallExpression.arguments(); ExpressionSequenceContext arktsExpressionSequence = arktsArguments.expressionSequence(); @@ -291,22 +302,21 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor { } public void apply(CallExpressionContext arktsCallExpression) { -// if (arktsMethodName != null) { -// assert (!arktsMethodName.isEmpty()); -// renameMethod(arktsCallExpression.singleExpression()); -// } -// List arktsOrigArguments = null; if (arguments != null || arktsObject != null) { arktsOrigArguments = getOrigArgs(arktsCallExpression); } - if (arktsTypeName != null && arktsTypeName.isEmpty()) { // Note: Here it's checked for NOT null AND empty string. + if (arktsTypeName != null) { assert (arktsObject == null); - makeMethodGlobal(arktsCallExpression); + if (arktsTypeName.isEmpty()) { // Note: Here it's checked for NOT null AND empty string. + makeMethodGlobal(arktsCallExpression); + } + else { + substituteType(arktsCallExpression); + } } else if (arktsObject != null) { - assert(arktsTypeName == null); substituteObject(arktsCallExpression, arktsOrigArguments); } @@ -530,6 +540,7 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor { static public String tag = "MemberAccessExpressionRule"; private String arktsName = null; + private TypeReference typeReference = null; // Optional ArkTS type for a static field access. // ArkTS: // | singleExpression Dot Identifier # MemberAccessExpression @@ -538,6 +549,11 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor { arktsMemberAccessExpression.children.remove(arktsMemberAccessExpression.Identifier()); arktsMemberAccessExpression.addChild(new TerminalNodeImpl(new CommonToken(StaticTSParser.Identifier, arktsName))); + + if (typeReference != null) { + arktsMemberAccessExpression.children.remove(arktsMemberAccessExpression.singleExpression()); + arktsMemberAccessExpression.addChild(typeReference.buildArktsNode(null)); + } } static private String signature(String javaObjectType, String javaName) { @@ -566,17 +582,30 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor { return signature(javaObjectType, javaName); } - static MemberAccessExpressionRule read(XMLEventReader xmlReader, XMLEvent xmlMemberAccessExpressionEvent, StartElement ruleStartElement) throws XMLStreamException { + static MemberAccessExpressionRule read(XMLEventReader xmlReader, StartElement ruleStartElement) throws XMLStreamException { MemberAccessExpressionRule memberAccessExpressionRule = new MemberAccessExpressionRule(); memberAccessExpressionRule.arktsName = getAttribute(ruleStartElement, arktsNameAttr); - // Read the end event () - assert (xmlReader.hasNext()); - XMLEvent xmlEvent = xmlReader.nextEvent(); - assert (xmlEvent.isEndElement()); - EndElement endElement = xmlEvent.asEndElement(); - assert (tag.equals(endElement.getName().getLocalPart())); + // Read an optional element and the end event () + while (xmlReader.hasNext()) { + XMLEvent xmlEvent = xmlReader.nextEvent(); + + if (xmlEvent.isStartElement()) { + StartElement startElement = xmlEvent.asStartElement(); + String tag = startElement.getName().getLocalPart(); + + if (TypeReference.tag.equals(tag)) { + memberAccessExpressionRule.typeReference = TypeReference.read(xmlReader, xmlEvent); + } + else assert false; + } + else if (xmlEvent.isEndElement()) { + EndElement endElement = xmlEvent.asEndElement(); + assert MemberAccessExpressionRule.tag.equals(endElement.getName().getLocalPart()); + break; + } + } return memberAccessExpressionRule; } @@ -934,7 +963,7 @@ public class JavaApiMapper extends StaticTSParserBaseVisitor { } else if (MemberAccessExpressionRule.tag.equals(tag)) { String signature = MemberAccessExpressionRule.signature(startElement); - MemberAccessExpressionRule rule = MemberAccessExpressionRule.read(xmlReader, xmlEvent, startElement); + MemberAccessExpressionRule rule = MemberAccessExpressionRule.read(xmlReader, startElement); assert !isStringEmpty(signature) && rule != null; memberAccessExpressionRules.put(signature, rule); diff --git a/migrator/src/com/ohos/migrator/java/JavaTransformer.java b/migrator/src/com/ohos/migrator/java/JavaTransformer.java index 1c86cfacf581189cff327383f3a19af11ade4841..9eb24295cedac1c87f6086e35f96befb71aa024b 100644 --- a/migrator/src/com/ohos/migrator/java/JavaTransformer.java +++ b/migrator/src/com/ohos/migrator/java/JavaTransformer.java @@ -1543,6 +1543,10 @@ public class JavaTransformer extends ASTVisitor implements Transformer { // singleExpression: | Identifier # IdentifierExpression @Override public boolean visit(QualifiedName javaQualifiedName) { + // TODO: Check if this javaQualifiedName referes to a calss static field access. Like: Character.MAX_HIGH_SURROGATE. + // In this case it has to be translated to a MemberAccessExpression and not to a simple Identifier. + // It's needed to let the ApiMapper to apply corresponding MemberAccessExpressionRule. + // See #272 String name = javaQualifiedName.getFullyQualifiedName(); stsCurrent.addChild(NodeBuilder.identifierExpression(name)).setParent(stsCurrent); // Don't count names as transformed as most of them are transformed manually. @@ -3061,12 +3065,15 @@ public class JavaTransformer extends ASTVisitor implements Transformer { javaClassType = javaCtorExpr.resolveTypeBinding(); } + ITypeBinding[] javaParamsTypes = null; + if (javaCtorBinding != null) { isThrowingCall = javaCtorBinding.getExceptionTypes().length > 0; if(isThrowingCall && checkThrownExceptionSet(javaCtorInvocation)) addMultipleThrownExceptions(javaCtorBinding.getExceptionTypes()); - stsConstructorCall.javaMethodArgs = buildSignature(javaCtorBinding.getParameterTypes()); + javaParamsTypes = javaCtorBinding.getParameterTypes(); + stsConstructorCall.javaMethodArgs = buildSignature(javaParamsTypes); if (javaCtorExpr == null) { javaClassType = javaCtorBinding.getDeclaringClass(); @@ -3097,7 +3104,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { translateTypeArguments(javaTypeArgs); stsConstructorCall.javaMethodTypeArgs = buildSignature(javaTypeArgs); - translateArguments(javaArgs); + translateArguments(javaArgs, javaParamsTypes); popCurrent(); // ConstructorCallContext @@ -3126,7 +3133,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { return false; } - private List translateArguments(List javaArgs) { + private List translateArguments(List javaArgs, ITypeBinding[] javaParamsTypes) { pushCurrent(new ArgumentsContext(stsCurrent, 0)); List result = null; @@ -3134,22 +3141,45 @@ public class JavaTransformer extends ASTVisitor implements Transformer { ExpressionSequenceContext stsExprSeq = new ExpressionSequenceContext(stsCurrent, 0); pushCurrent(stsExprSeq); - for (Expression javaExpr : javaArgs) { + int nargs = javaArgs.size(); + int n = nargs; + // For the case of vararg the number of actual arguments may be more than the list of formal parameters. + // In such case the last format parameter type has to be an array. + if (javaParamsTypes != null && javaParamsTypes.length < nargs) { + // The last parameter should be of array type to which all ending extra arguments will be packed. + n = javaParamsTypes.length - 1; + assert (javaParamsTypes[n].isArray()) : "For vararg functions the last parameter has to be an array."; + } + + for (int i = 0; i < n; i++) { + Expression javaExpr = javaArgs.get(i); + ITypeBinding javaTypeBinding = javaExpr.resolveTypeBinding(); - if (javaTypeBinding != null) { - sbForApiMapper.append(javaTypeBinding.getQualifiedName()); - } - else { + if (javaTypeBinding == null) { reportError("Fail to resolve argument", javaExpr); } - sbForApiMapper.append(','); - javaExpr.accept(this); } - if (sbForApiMapper.length() > 1) { - sbForApiMapper.setLength(sbForApiMapper.length() - 1); // Remove the ending extra comma. + System.out.printf("f", 1, 3); + + if (n < nargs) { + pushCurrent(new ArrayLiteralExpressionContext(pushSingleExpression())); + pushCurrent(new ExpressionSequenceContext(stsCurrent, 0)); + + for (int i = n; i < nargs; i++) { + Expression javaExpr = javaArgs.get(i); + javaExpr.accept(this); + + ITypeBinding javaTypeBinding = javaExpr.resolveTypeBinding(); + if (javaTypeBinding == null) { + reportError("Fail to resolve argument", javaExpr); + } + } + + popCurrent(); // ExpressionSequenceContext + popSingleExpression(); // ArrayLiteralContext } popCurrent(); // ExpressionSequenceContext @@ -3342,7 +3372,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { // AnonymousClassDeclaration: { ClassBodyDeclaration } // STS tree: // singleExpression: - // | New (singleExpression Dot)? typeReference arguments? classBody? # NewClassExpression + // | New typeArguments? typeReference arguments? classBody? # NewClassInstanceExpression // arguments: OpenParen expressionSequence? CloseParen // classBody: OpenBrace classMember* clinit=classInitializer? classMember* CloseBrace // NOTE: If ctor called by class instance creation expression can throw exceptions, @@ -3405,12 +3435,15 @@ public class JavaTransformer extends ASTVisitor implements Transformer { reportError("Fail to resolve class type", javaClassType); } - List stsArgs = translateArguments(javaClassInstanceCreation.arguments()); + ITypeBinding[] javaParamsTypes = null; if (javaCtorBinding != null) { - stsNewClassInstanceExpr.javaMethodArgs = buildSignature(javaCtorBinding.getParameterTypes()); + javaParamsTypes = javaCtorBinding.getParameterTypes(); + stsNewClassInstanceExpr.javaMethodArgs = buildSignature(javaParamsTypes); } + List stsArgs = translateArguments(javaClassInstanceCreation.arguments(), javaParamsTypes); + AnonymousClassDeclaration javaAnonymousClassDeclaration = javaClassInstanceCreation.getAnonymousClassDeclaration(); if (javaAnonymousClassDeclaration != null) { @@ -3800,12 +3833,15 @@ public class JavaTransformer extends ASTVisitor implements Transformer { translateTypeArguments(javaMethodInvocation.typeArguments()); stsCallExpression.javaMethodTypeArgs = buildSignature(javaMethodInvocation.typeArguments()); - translateArguments(javaMethodInvocation.arguments()); + ITypeBinding[] javaParamsTypes = null; if (javaMethodBinding != null) { - stsCallExpression.javaMethodArgs = buildSignature(javaMethodBinding.getParameterTypes()); + javaParamsTypes = javaMethodBinding.getParameterTypes(); + stsCallExpression.javaMethodArgs = buildSignature(javaParamsTypes); } + translateArguments(javaMethodInvocation.arguments(), javaParamsTypes); + popSingleExpression(); // CallExpressionContext if (isThrowingCall) { @@ -3879,11 +3915,14 @@ public class JavaTransformer extends ASTVisitor implements Transformer { translateTypeArguments(javaSuperMethodInvocation.typeArguments()); stsCallExpression.javaTypeArgs = buildSignature(javaSuperMethodInvocation.typeArguments()); + ITypeBinding[] javaParamsTypes = null; + if (javaMethodBinding != null) { - stsCallExpression.javaMethodArgs = buildSignature(javaMethodBinding.getParameterTypes()); + javaParamsTypes = javaMethodBinding.getParameterTypes(); + stsCallExpression.javaMethodArgs = buildSignature(javaParamsTypes); } - translateArguments(javaSuperMethodInvocation.arguments()); + translateArguments(javaSuperMethodInvocation.arguments(), javaParamsTypes); popSingleExpression(); // CallExpressionContext diff --git a/migrator/test/java-mapper/CallExpressionRulesByte.java b/migrator/test/java-mapper/CallExpressionRulesByte.java new file mode 100644 index 0000000000000000000000000000000000000000..14b6b2c82c6356d9d913153b5b1374250553ad50 --- /dev/null +++ b/migrator/test/java-mapper/CallExpressionRulesByte.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.ohos.migrator.test.java; + +class CallExpressiontRulesByte { + public static void Test() { + byte v1 = 3; + byte v2 = 4; + int res = Byte.compare(v1, v2); + + int hesh = Byte.hashCode((byte)3); + + String s = Byte.toString((byte)8); + } +} \ No newline at end of file diff --git a/migrator/test/java-mapper/CallExpressionRulesByte.java.sts b/migrator/test/java-mapper/CallExpressionRulesByte.java.sts new file mode 100644 index 0000000000000000000000000000000000000000..f8e9f6557dd36aa51c8cdd3208042928afb033ac --- /dev/null +++ b/migrator/test/java-mapper/CallExpressionRulesByte.java.sts @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.ohos.migrator.test.java; + +import * from "std/math/math"; +open class CallExpressiontRulesByte { + public static Test(): void { + let v1 : byte = 3; + let v2 : byte = 4; + let res : int = new Byte(v1).compareTo(new Byte(v2)); + let hesh : int = Byte.hashCode(3 as byte); + let s : String = new Byte(8 as byte).toString(); + } +} + diff --git a/migrator/test/java-mapper/CallExpressionRulesCharacter.java b/migrator/test/java-mapper/CallExpressionRulesCharacter.java new file mode 100644 index 0000000000000000000000000000000000000000..65010899afe7e670a32db692c24aa7539492207c --- /dev/null +++ b/migrator/test/java-mapper/CallExpressionRulesCharacter.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.ohos.migrator.test.java; + +class CallExpressiontRulesCharacter { + public static void Test() { + Character c = new Character('g'); + + int res = Character.compare('c', 'b'); + + int hash = Character.hashCode('3'); + + c = Character.highSurrogate(386); + c = Character.lowSurrogate(386); + + boolean b; + b = Character.isDigit('8'); + b = Character.isHighSurrogate('c'); + b = Character.isLetter('8'); + b = Character.isLowerCase('8'); + b = Character.isLowSurrogate('8'); + b = Character.isUpperCase('8'); + b = Character.isWhitespace('8'); + + c = Character.toLowerCase('C'); + c = Character.toUpperCase('a'); + + Character ch = Character.valueOf('d'); + + String s = Character.toString('s'); + } +} \ No newline at end of file diff --git a/migrator/test/java-mapper/CallExpressionRulesCharacter.java.sts b/migrator/test/java-mapper/CallExpressionRulesCharacter.java.sts new file mode 100644 index 0000000000000000000000000000000000000000..b91955fafdac564e741a8422843488ffed56df16 --- /dev/null +++ b/migrator/test/java-mapper/CallExpressionRulesCharacter.java.sts @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.ohos.migrator.test.java; + +import * from "std/math/math"; +open class CallExpressiontRulesCharacter { + public static Test(): void { + let c : Char = new Char('g'); + let res : int = new Char('c').compareTo(new Char('b')); + let hash : int = Char.hashCode('3'); + c = Char.getHighSurrogate(386); + c = Char.getLowSurrogate(386); + let b : boolean ; + b = Char.isDecDigit('8'); + b = Char.isHighSurrogate('c'); + b = Char.isLetter('8'); + b = Char.isLowerCase('8'); + b = Char.isLowSurrogate('8'); + b = Char.isUpperCase('8'); + b = Char.isWhitespace('8'); + c = Char.toLowerCase('C'); + c = Char.toUpperCase('a'); + let ch : Char = Char.valueOf('d'); + let s : String = new Char('s').toString(); + } +} + diff --git a/migrator/test/java-mapper/CallExpressionRulesString.java b/migrator/test/java-mapper/CallExpressionRulesString.java new file mode 100644 index 0000000000000000000000000000000000000000..e590bc8cee80609f39f1ee0cb8dd115b29d49c6d --- /dev/null +++ b/migrator/test/java-mapper/CallExpressionRulesString.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.ohos.migrator.test.java; + +import java.util.List; +import java.util.ArrayList; + +class CallExpressiontRulesString { + public static void Test() { + String s1 = new String("abc"); + boolean b = s1.contains("d"); + +// List l = new ArrayList<>(2); +// l.add("a"); +// l.add("b"); + +// List strs = l; +// +// String s2 = String.join("+", strs); + + String s3 = String.join("+", "a", "b", "c"); + + String sc = String.valueOf('c'); + String si = String.valueOf(1); + String sl = String.valueOf(2l); + String sf = String.valueOf(3.f); + String sd = String.valueOf(4.); + } +} \ No newline at end of file diff --git a/migrator/test/java-mapper/CallExpressionRulesString.java.sts b/migrator/test/java-mapper/CallExpressionRulesString.java.sts new file mode 100644 index 0000000000000000000000000000000000000000..96b6a5d29d79a4a651fb2cffc04fdede22dbd6ed --- /dev/null +++ b/migrator/test/java-mapper/CallExpressionRulesString.java.sts @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.ohos.migrator.test.java; + +import * from "std/math/math"; +import List from "java/util"; +import ArrayList from "java/util"; +open class CallExpressiontRulesString { + public static Test(): void { + let s1 : String = new String("abc"); + let b : boolean = s1.contains("d", 0); +// List l = new ArrayList<>(2); +// l.add("a"); +// l.add("b"); +// List strs = l; +// +// String s2 = String.join("+", strs); + let s3 : String = String.join(["a", "b", "c"], "+"); + let sc : String = StringBuilder.toString('c'); + let si : String = StringBuilder.toString(1); + let sl : String = StringBuilder.toString(2 as long); + let sf : String = StringBuilder.toString(3. as float); + let sd : String = StringBuilder.toString(4.); + } +} + diff --git a/migrator/test/java/varargs_function.java b/migrator/test/java/varargs_function.java new file mode 100644 index 0000000000000000000000000000000000000000..322e090be3c3e736f3b0627a83939fcf5d5520d0 --- /dev/null +++ b/migrator/test/java/varargs_function.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.ohos.migrator.test.java; + +class varargs_function { + public static void main(String[] args) { + foo(1, 3, 7); + } + + static void foo(Object... args) + { + int n = args.length; + System.out.println(n); + } +} diff --git a/migrator/test/java/varargs_function.java.sts b/migrator/test/java/varargs_function.java.sts new file mode 100644 index 0000000000000000000000000000000000000000..e2afe6ac5faae4a67267cdd1378f6593b22c699c --- /dev/null +++ b/migrator/test/java/varargs_function.java.sts @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2022-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.ohos.migrator.test.java; + +import * from "std/math/math"; +open class varargs_function { + public static main(args : String[]): void { + foo([1, 3, 7]); + } + static foo(... args: Object ): void { + let n : int = args.length; + System.out.println(n); + } +} +