Skip to content

Commit a276f0e

Browse files
oderskyodersky
committed
Implement generic number literals
### Example: ``` val x: BigInt = 111111100000022222222222 ``` ### Also allow generic literals in patterns Wrap generic literals in patterns in blocks, which force expression evaluation. This allows to match (say) a scrutinee of BigInt type against large numeric literals. But it does not work if the scrutinee is of type `Any` because then the expeected type for the pattern is missing. This would be addressed by a feature that's still missing: patterns of the form `<literal> : <type>`. We have to change the syntax of patterns in general for this one.
1 parent 8cf938d commit a276f0e

File tree

26 files changed

+859
-162
lines changed

26 files changed

+859
-162
lines changed

‎compiler/src/dotty/tools/dotc/ast/untpd.scala

Lines changed: 14 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -109,6 +109,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
109109
case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree])(implicit @constructorOnly src: SourceFile) extends TypTree
110110
case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(implicit @constructorOnly src: SourceFile) extends DefTree
111111
case class Export(impliedOnly: Boolean, expr: Tree, selectors: List[Tree])(implicit @constructorOnly src: SourceFile) extends Tree
112+
case class Number(digits: String, kind: NumberKind)(implicit @constructorOnly src: SourceFile) extends TermTree
113+
114+
enum NumberKind {
115+
case Whole(radix: Int)
116+
case Decimal
117+
case Floating
118+
}
112119

113120
/** Short-lived usage in typer, does not need copy/transform/fold infrastructure */
114121
case class DependentTypeTree(tp: List[Symbol] => Type)(implicit @constructorOnly src: SourceFile) extends Tree
@@ -558,6 +565,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
558565
case tree: Export if (impliedOnly == tree.impliedOnly) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
559566
case _ => finalize(tree, untpd.Export(impliedOnly, expr, selectors)(tree.source))
560567
}
568+
def Number(tree: Tree)(digits: String, kind: NumberKind)(implicit ctx: Context): Tree = tree match {
569+
case tree: Number if (digits == tree.digits) && (kind == tree.kind) => tree
570+
case _ => finalize(tree, untpd.Number(digits, kind))
571+
}
561572
def TypedSplice(tree: Tree)(splice: tpd.Tree)(implicit ctx: Context): ProxyTree = tree match {
562573
case tree: TypedSplice if splice `eq` tree.splice => tree
563574
case _ => finalize(tree, untpd.TypedSplice(splice)(ctx))
@@ -612,7 +623,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
612623
cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
613624
case Export(impliedOnly, expr, selectors) =>
614625
cpy.Export(tree)(impliedOnly, transform(expr), selectors)
615-
case TypedSplice(_) =>
626+
case Number(_, _) | TypedSplice(_) =>
616627
tree
617628
case _ =>
618629
super.transformMoreCases(tree)
@@ -667,6 +678,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
667678
this(this(this(x, pats), tpt), rhs)
668679
case Export(_, expr, _) =>
669680
this(x, expr)
681+
case Number(_, _) =>
682+
x
670683
case TypedSplice(splice) =>
671684
this(x, splice)
672685
case _ =>

‎compiler/src/dotty/tools/dotc/core/Definitions.scala

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -669,7 +669,18 @@ class Definitions {
669669
@tu lazy val StatsModule: Symbol = ctx.requiredModule("dotty.tools.dotc.util.Stats")
670670
@tu lazy val Stats_doRecord: Symbol = StatsModule.requiredMethod("doRecord")
671671

672-
@tu lazy val XMLTopScopeModule: Symbol = ctx.requiredModule("scala.xml.TopScope")
672+
@threadUnsafe lazy val FromDigitsClass: ClassSymbolPerRun = perRunClass(ctx.requiredClassRef("scala.util.FromDigits"))
673+
@threadUnsafe lazy val FromDigits_WithRadixClass: ClassSymbolPerRun = perRunClass(ctx.requiredClassRef("scala.util.FromDigits.WithRadix"))
674+
@threadUnsafe lazy val FromDigits_DecimalClass: ClassSymbolPerRun = perRunClass(ctx.requiredClassRef("scala.util.FromDigits.Decimal"))
675+
@threadUnsafe lazy val FromDigits_FloatingClass: ClassSymbolPerRun = perRunClass(ctx.requiredClassRef("scala.util.FromDigits.Floating"))
676+
677+
@threadUnsafe lazy val XMLTopScopeModule: SymbolPerRun = perRunSym(ctx.requiredModuleRef("scala.xml.TopScope"))
678+
679+
@threadUnsafe lazy val CommandLineParserModule: SymbolPerRun = perRunSym(ctx.requiredModuleRef("scala.util.CommandLineParser"))
680+
@threadUnsafe lazy val CLP_ParseError: ClassSymbolPerRun = perRunClass(CommandLineParserModule.requiredClass("ParseError").typeRef)
681+
@threadUnsafe lazy val CLP_parseArgument: SymbolPerRun = perRunSym(CommandLineParserModule.requiredMethodRef("parseArgument"))
682+
@threadUnsafe lazy val CLP_parseRemainingArguments: SymbolPerRun = perRunSym(CommandLineParserModule.requiredMethodRef("parseRemainingArguments"))
683+
@threadUnsafe lazy val CLP_showError: SymbolPerRun = perRunSym(CommandLineParserModule.requiredMethodRef("showError"))
673684

674685
@tu lazy val CommandLineParserModule: Symbol = ctx.requiredModule("scala.util.CommandLineParser")
675686
@tu lazy val CLP_ParseError: ClassSymbol = CommandLineParserModule.requiredClass("ParseError").typeRef.symbol.asClass

‎compiler/src/dotty/tools/dotc/core/StdNames.scala

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -442,6 +442,7 @@ object StdNames {
442442
val flagsFromBits : N = "flagsFromBits"
443443
val flatMap: N = "flatMap"
444444
val foreach: N = "foreach"
445+
val fromDigits: N = "fromDigits"
445446
val fromProduct: N = "fromProduct"
446447
val genericArrayOps: N = "genericArrayOps"
447448
val genericClass: N = "genericClass"

‎compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala

Lines changed: 7 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -519,20 +519,13 @@ object JavaScanners {
519519
// Errors -----------------------------------------------------------------
520520

521521
override def toString(): String = token match {
522-
case IDENTIFIER =>
523-
"id(" + name + ")"
524-
case CHARLIT =>
525-
"char(" + intVal + ")"
526-
case INTLIT =>
527-
"int(" + intVal + ")"
528-
case LONGLIT =>
529-
"long(" + intVal + ")"
530-
case FLOATLIT =>
531-
"float(" + floatVal + ")"
532-
case DOUBLELIT =>
533-
"double(" + doubleVal + ")"
534-
case STRINGLIT =>
535-
"string(" + name + ")"
522+
case IDENTIFIER => s"id($name)"
523+
case CHARLIT => s"char($strVal)"
524+
case INTLIT => s"int($strVal, $base)"
525+
case LONGLIT => s"long($strVal, $base)"
526+
case FLOATLIT => s"float($strVal)"
527+
case DOUBLELIT => s"double($strVal)"
528+
case STRINGLIT => s"string($strVal)"
536529
case SEMI =>
537530
";"
538531
case COMMA =>

‎compiler/src/dotty/tools/dotc/parsing/Parsers.scala

Lines changed: 35 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1016,24 +1016,37 @@ object Parsers {
10161016
* @param negOffset The offset of a preceding `-' sign, if any.
10171017
* If the literal is not negated, negOffset = in.offset.
10181018
*/
1019-
def literal(negOffset: Int = in.offset, inPattern: Boolean = false, inStringInterpolation: Boolean = false): Tree = {
1020-
1021-
def literalOf(token: Token): Literal = {
1019+
def literal(negOffset: Int = in.offset, inPattern: Boolean = false, inType: Boolean = false, inStringInterpolation: Boolean = false): Tree = {
1020+
def literalOf(token: Token): Tree = {
10221021
val isNegated = negOffset < in.offset
1023-
val value = token match {
1024-
case CHARLIT => in.charVal
1025-
case INTLIT => in.intVal(isNegated).toInt
1026-
case LONGLIT => in.intVal(isNegated)
1027-
case FLOATLIT => in.floatVal(isNegated).toFloat
1028-
case DOUBLELIT => in.doubleVal(isNegated)
1029-
case STRINGLIT | STRINGPART => in.strVal
1030-
case TRUE => true
1031-
case FALSE => false
1032-
case NULL => null
1033-
case _ =>
1034-
syntaxErrorOrIncomplete(IllegalLiteral())
1035-
null
1036-
}
1022+
def digits0 = in.removeNumberSeparators(in.strVal)
1023+
def digits = if (isNegated) "-" + digits0 else digits0
1024+
if (!inType)
1025+
token match {
1026+
case INTLIT => return Number(digits, NumberKind.Whole(in.base))
1027+
case DECILIT => return Number(digits, NumberKind.Decimal)
1028+
case EXPOLIT => return Number(digits, NumberKind.Floating)
1029+
case _ =>
1030+
}
1031+
import scala.util.FromDigits._
1032+
val value =
1033+
try token match {
1034+
case INTLIT => intFromDigits(digits, in.base)
1035+
case LONGLIT => longFromDigits(digits, in.base)
1036+
case FLOATLIT => floatFromDigits(digits)
1037+
case DOUBLELIT | DECILIT | EXPOLIT => doubleFromDigits(digits)
1038+
case CHARLIT => in.strVal.head
1039+
case STRINGLIT | STRINGPART => in.strVal
1040+
case TRUE => true
1041+
case FALSE => false
1042+
case NULL => null
1043+
case _ =>
1044+
syntaxErrorOrIncomplete(IllegalLiteral())
1045+
null
1046+
}
1047+
catch {
1048+
case ex: FromDigitsException => syntaxErrorOrIncomplete(ex.getMessage)
1049+
}
10371050
Literal(Constant(value))
10381051
}
10391052

@@ -1163,6 +1176,7 @@ object Parsers {
11631176
}
11641177

11651178
/* ------------- TYPES ------------------------------------------------------ */
1179+
11661180
/** Same as [[typ]], but if this results in a wildcard it emits a syntax error and
11671181
* returns a tree for type `Any` instead.
11681182
*/
@@ -1378,11 +1392,11 @@ object Parsers {
13781392
}
13791393
else if (in.token == LBRACE)
13801394
atSpan(in.offset) { RefinedTypeTree(EmptyTree, refinement()) }
1381-
else if (isSimpleLiteral) { SingletonTypeTree(literal()) }
1395+
else if (isSimpleLiteral) { SingletonTypeTree(literal(inType = true)) }
13821396
else if (isIdent(nme.raw.MINUS) && in.lookaheadIn(numericLitTokens)) {
13831397
val start = in.offset
13841398
in.nextToken()
1385-
SingletonTypeTree(literal(negOffset = start))
1399+
SingletonTypeTree(literal(negOffset = start, inType = true))
13861400
}
13871401
else if (in.token == USCORE) {
13881402
if (ctx.settings.strict.value) {
@@ -2329,12 +2343,11 @@ object Parsers {
23292343
if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1() :: patternAlts() }
23302344
else Nil
23312345

2332-
/** Pattern1 ::= PatVar Ascription
2333-
* | Pattern2
2346+
/** Pattern1 ::= Pattern2 [Ascription]
23342347
*/
23352348
def pattern1(): Tree = {
23362349
val p = pattern2()
2337-
if (isVarPattern(p) && in.token == COLON) {
2350+
if (in.token == COLON) {
23382351
in.nextToken()
23392352
ascription(p, Location.InPattern)
23402353
}

‎compiler/src/dotty/tools/dotc/parsing/Scanners.scala

Lines changed: 8 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -123,99 +123,10 @@ object Scanners {
123123
def setStrVal(): Unit =
124124
strVal = flushBuf(litBuf)
125125

126-
/** Convert current strVal to char value
127-
*/
128-
def charVal: Char = if (strVal.length > 0) strVal.charAt(0) else 0
129-
130-
/** Convert current strVal, base to long value
131-
* This is tricky because of max negative value.
132-
*/
133-
def intVal(negated: Boolean): Long =
134-
if (token == CHARLIT && !negated)
135-
charVal
136-
else {
137-
var value: Long = 0
138-
val divider = if (base == 10) 1 else 2
139-
val limit: Long =
140-
if (token == LONGLIT) Long.MaxValue else Int.MaxValue
141-
var i = 0
142-
val len = strVal.length
143-
while (i < len) {
144-
val c = strVal charAt i
145-
if (! isNumberSeparator(c)) {
146-
val d = digit2int(c, base)
147-
if (d < 0) {
148-
error(s"malformed integer number")
149-
return 0
150-
}
151-
if (value < 0 ||
152-
limit / (base / divider) < value ||
153-
limit - (d / divider) < value * (base / divider) &&
154-
!(negated && limit == value * base - 1 + d)) {
155-
error("integer number too large")
156-
return 0
157-
}
158-
value = value * base + d
159-
}
160-
i += 1
161-
}
162-
if (negated) -value else value
163-
}
164-
165-
def intVal: Long = intVal(false)
166-
167-
private val zeroFloat = raw"[0.]+(?:[eE][+-]?[0-9]+)?[fFdD]?".r
168-
169-
/** Convert current strVal, base to double value
170-
*/
171-
def floatVal(negated: Boolean): Float = {
172-
assert(token == FLOATLIT)
173-
val text = removeNumberSeparators(strVal)
174-
try {
175-
val value: Float = java.lang.Float.valueOf(text).floatValue()
176-
if (value > Float.MaxValue)
177-
errorButContinue("floating point number too large")
178-
179-
if (value == 0.0f && !zeroFloat.pattern.matcher(text).matches)
180-
errorButContinue("floating point number too small")
181-
if (negated) -value else value
182-
}
183-
catch {
184-
case _: NumberFormatException =>
185-
error("malformed floating point number")
186-
0.0f
187-
}
188-
}
189-
190-
def floatVal: Float = floatVal(false)
191-
192-
/** Convert current strVal, base to double value
193-
*/
194-
def doubleVal(negated: Boolean): Double = {
195-
assert(token == DOUBLELIT)
196-
val text = removeNumberSeparators(strVal)
197-
try {
198-
val value: Double = java.lang.Double.valueOf(text).doubleValue()
199-
if (value > Double.MaxValue)
200-
errorButContinue("double precision floating point number too large")
201-
202-
if (value == 0.0d && !zeroFloat.pattern.matcher(text).matches)
203-
errorButContinue("double precision floating point number too small")
204-
if (negated) -value else value
205-
}
206-
catch {
207-
case _: NumberFormatException =>
208-
error("malformed floating point number")
209-
0.0
210-
}
211-
}
212-
213-
def doubleVal: Double = doubleVal(false)
214-
215126
@inline def isNumberSeparator(c: Char): Boolean = c == '_'
216127

217128
@inline def removeNumberSeparators(s: String): String =
218-
if (s.indexOf('_') > 0) s.replaceAllLiterally("_", "") /*.replaceAll("'","")*/ else s
129+
if (s.indexOf('_') > 0) s.replaceAllLiterally("_", "") else s
219130

220131
// disallow trailing numeric separator char, but continue lexing
221132
def checkNoTrailingSeparator(): Unit =
@@ -1228,7 +1139,7 @@ object Scanners {
12281139
* if one is present.
12291140
*/
12301141
protected def getFraction(): Unit = {
1231-
token = DOUBLELIT
1142+
token = DECILIT
12321143
while ('0' <= ch && ch <= '9' || isNumberSeparator(ch)) {
12331144
putChar(ch)
12341145
nextChar()
@@ -1252,7 +1163,7 @@ object Scanners {
12521163
}
12531164
checkNoTrailingSeparator()
12541165
}
1255-
token = DOUBLELIT
1166+
token = EXPOLIT
12561167
}
12571168
if (ch == 'd' || ch == 'D') {
12581169
putChar(ch)
@@ -1329,11 +1240,11 @@ object Scanners {
13291240

13301241
def show: String = token match {
13311242
case IDENTIFIER | BACKQUOTED_IDENT => s"id($name)"
1332-
case CHARLIT => s"char($intVal)"
1333-
case INTLIT => s"int($intVal)"
1334-
case LONGLIT => s"long($intVal)"
1335-
case FLOATLIT => s"float($floatVal)"
1336-
case DOUBLELIT => s"double($doubleVal)"
1243+
case CHARLIT => s"char($strVal)"
1244+
case INTLIT => s"int($strVal, $base)"
1245+
case LONGLIT => s"long($strVal, $base)"
1246+
case FLOATLIT => s"float($strVal)"
1247+
case DOUBLELIT => s"double($strVal)"
13371248
case STRINGLIT => s"string($strVal)"
13381249
case STRINGPART => s"stringpart($strVal)"
13391250
case INTERPOLATIONID => s"interpolationid($name)"

‎compiler/src/dotty/tools/dotc/parsing/Tokens.scala

Lines changed: 15 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -37,17 +37,19 @@ abstract class TokensCommon {
3737
/** literals */
3838
final val CHARLIT = 3; enter(CHARLIT, "character literal")
3939
final val INTLIT = 4; enter(INTLIT, "integer literal")
40-
final val LONGLIT = 5; enter(LONGLIT, "long literal")
41-
final val FLOATLIT = 6; enter(FLOATLIT, "float literal")
42-
final val DOUBLELIT = 7; enter(DOUBLELIT, "double literal")
43-
final val STRINGLIT = 8; enter(STRINGLIT, "string literal")
44-
final val STRINGPART = 9; enter(STRINGPART, "string literal", "string literal part")
45-
//final val INTERPOLATIONID = 10; enter(INTERPOLATIONID, "string interpolator")
46-
//final val QUOTEID = 11; enter(QUOTEID, "quoted identifier") // TODO: deprecate
40+
final val DECILIT = 5; enter(DECILIT, "number literal") // with decimal point
41+
final val EXPOLIT = 6; enter(EXPOLIT, "number literal with exponent")
42+
final val LONGLIT = 7; enter(LONGLIT, "long literal")
43+
final val FLOATLIT = 8; enter(FLOATLIT, "float literal")
44+
final val DOUBLELIT = 9; enter(DOUBLELIT, "double literal")
45+
final val STRINGLIT = 10; enter(STRINGLIT, "string literal")
46+
final val STRINGPART = 11; enter(STRINGPART, "string literal", "string literal part")
47+
//final val INTERPOLATIONID = 12; enter(INTERPOLATIONID, "string interpolator")
48+
//final val QUOTEID = 13; enter(QUOTEID, "quoted identifier") // TODO: deprecate
4749

4850
/** identifiers */
49-
final val IDENTIFIER = 12; enter(IDENTIFIER, "identifier")
50-
//final val BACKQUOTED_IDENT = 13; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
51+
final val IDENTIFIER = 14; enter(IDENTIFIER, "identifier")
52+
//final val BACKQUOTED_IDENT = 15; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
5153

5254
/** alphabetic keywords */
5355
final val IF = 20; enter(IF, "if")
@@ -150,10 +152,10 @@ object Tokens extends TokensCommon {
150152
final val minToken = EMPTY
151153
final def maxToken: Int = XMLSTART
152154

153-
final val INTERPOLATIONID = 10; enter(INTERPOLATIONID, "string interpolator")
154-
final val QUOTEID = 11; enter(QUOTEID, "quoted identifier") // TODO: deprecate
155+
final val INTERPOLATIONID = 12; enter(INTERPOLATIONID, "string interpolator")
156+
final val QUOTEID = 13; enter(QUOTEID, "quoted identifier") // TODO: deprecate
155157

156-
final val BACKQUOTED_IDENT = 13; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
158+
final val BACKQUOTED_IDENT = 15; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
157159

158160
final val identifierTokens: TokenSet = BitSet(IDENTIFIER, BACKQUOTED_IDENT)
159161

@@ -260,7 +262,7 @@ object Tokens extends TokensCommon {
260262
final val stopScanTokens: BitSet = mustStartStatTokens |
261263
BitSet(IF, ELSE, WHILE, DO, FOR, YIELD, NEW, TRY, CATCH, FINALLY, THROW, RETURN, MATCH, SEMI, EOF)
262264

263-
final val numericLitTokens: TokenSet = BitSet(INTLIT, LONGLIT, FLOATLIT, DOUBLELIT)
265+
final val numericLitTokens: TokenSet = BitSet(INTLIT, DECILIT, EXPOLIT, LONGLIT, FLOATLIT, DOUBLELIT)
264266

265267
final val statCtdTokens: BitSet = BitSet(THEN, ELSE, DO, CATCH, FINALLY, YIELD, MATCH)
266268

‎compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -604,6 +604,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
604604
changePrec(GlobalPrec) {
605605
keywordStr("try ") ~ toText(expr) ~ " " ~ keywordStr("catch") ~ " {" ~ toText(handler) ~ "}" ~ optText(finalizer)(keywordStr(" finally ") ~ _)
606606
}
607+
case Number(digits, kind) =>
608+
digits
607609
case Quote(tree) =>
608610
if (tree.isType) keywordStr("'[") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("]")
609611
else keywordStr("'{") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")

0 commit comments

Comments
 (0)